public Desk[,] GetDeskGridLayout()
{
Desk next, desk = GetUpperLeftDesk();
Gdk.Point gridsize = GetDeskGridSize();
Desk [,] grid = new Desk [gridsize.X, gridsize.Y];
grid [0, 0] = desk;
int x = 0;
for (int y = 0; y < gridsize.Y; y++)
{
x = 0;
while ((next = desk.GetNeighbor(Wnck.MotionDirection.Right)) != null)
{
desk = next;
x++;
if (gridsize.X - 1 < x)
{
break;
}
grid [x, y] = desk;
}
if (gridsize.Y - 1 > y)
{
desk = (grid [0, y] != null ? grid [0, y].GetNeighbor(Wnck.MotionDirection.Down) : null);
grid [0, y + 1] = desk;
}
}
return(grid);
}
private void RefreshFlyoutLayoutBehavior(FlyoutLayoutBehaviorType flyoutBehaviorType)
{
int detailWidthRequest = 0;
Gdk.Point point = default(Gdk.Point);
switch (_flyoutBehaviorType)
{
case FlyoutLayoutBehaviorType.Split:
detailWidthRequest = _lastAllocation.Width - DefaultFlyoutWidth;
point = new Gdk.Point(_flyout.WidthRequest, 0);
break;
case FlyoutLayoutBehaviorType.Default:
case FlyoutLayoutBehaviorType.Popover:
detailWidthRequest = _lastAllocation.Width;
point = new Gdk.Point(0, 0);
break;
}
if (detailWidthRequest >= 0)
{
_detail.WidthRequest = detailWidthRequest;
_detail.MoveTo(point.X, point.Y);
}
}
void HandleButtonPressEvent(object sender, ButtonPressEventArgs args)
{
switch (args.Event.Type)
{
case EventType.ButtonPress:
if (args.Event.Button == 1)
{
start = new Gdk.Point((int)args.Event.X, (int)args.Event.Y);
start_root = new Gdk.Point((int)args.Event.XRoot, (int)args.Event.YRoot);
start_hot = hotspot;
Gdk.Point win;
GdkWindow.GetOrigin(out win.X, out win.Y);
start_hot.X += win.X;
start_hot.Y += win.Y;
dragging = true;
rotate = (args.Event.State & ModifierType.ShiftMask) > 0;
start_angle = Angle;
}
else
{
Angle += Math.PI / 8;
}
break;
case EventType.TwoButtonPress:
dragging = false;
App.Instance.Organizer.HideLoupe();
break;
}
}
private void GdkDraw(EventExpose evnt, int height, int width)
{
Time time = new Time();
width = Math.Min(width, this.Allocation.Width);
layout.SetMarkup("0");
this.GdkWindow.DrawLayout(this.Style.TextGC(StateType.Normal), 0, height - 23, layout);
Gdk.Point topL = new Gdk.Point((int)(CurrentFrame / pixelRatio - Scroll - 5), height - 15);
Gdk.Point topR = new Gdk.Point((int)(CurrentFrame / pixelRatio - Scroll + 5), height - 15);
Gdk.Point bottom = new Gdk.Point((int)(CurrentFrame / pixelRatio - Scroll), height);
this.GdkWindow.DrawPolygon(this.Style.TextGC(StateType.Normal), true, new Gdk.Point[] { topL, topR, bottom });
for (int i = 10 * FrameRate; i <= frames / pixelRatio;)
{
// Drawing separator line
evnt.Window.DrawLine(Style.DarkGC(StateType.Normal), i - (int)Scroll, height, i - (int)Scroll, height - 10);
time.Seconds = (int)(i / FrameRate * pixelRatio);
layout.SetMarkup(time.ToSecondsString());
this.GdkWindow.DrawLayout(this.Style.TextGC(StateType.Normal), i - (int)Scroll - 13, height - 23, layout);
//g.ShowText(time.ToSecondsString());
i = i + 10 * FrameRate;
}
for (int i = 0; i <= frames / pixelRatio;)
{
evnt.Window.DrawLine(Style.DarkGC(StateType.Normal), i - (int)Scroll, height, i - (int)Scroll, height - 5);
i = i + FrameRate;
}
// Drawing main line
evnt.Window.DrawLine(Style.DarkGC(StateType.Normal), 0, height, width, height);
}
//on inertial also uses to EncoderCapturePointsInertialDisc
protected virtual void encoderCapturePointsAdaptativeDisplay()
{
//adaptative displayed height
//if points go outside the graph, duplicate size of graph
if (EncoderCapturePoints[i].Y > heightG || EncoderCapturePoints[i].Y < 0)
{
realHeightG *= 2;
int xWidth = recordingTime;
if (cont)
{
xWidth = recordedTimeCont;
}
double sum2 = 0;
for (int j = 0; j <= i; j++)
{
sum2 += encoderReaded[j];
EncoderCapturePoints[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / xWidth),
Convert.ToInt32((heightG / 2) - (sum2 * heightG / realHeightG))
);
}
EncoderCapturePointsCaptured = i;
EncoderCapturePointsPainted = -1; //mark meaning screen should be erased
}
}
protected override bool OnButtonPressEvent(EventButton evnt)
{
Gdk.Point global_point = new Gdk.Point((int)evnt.XRoot, (int)evnt.YRoot);
Gdk.Point local_point = new Gdk.Point((int)evnt.X, (int)evnt.Y);
switch (bezel_drawing_area.GetPointLocation(local_point))
{
case PointLocation.Close:
case PointLocation.Outside:
controller.ButtonPressOffWindow();
break;
case PointLocation.Preferences:
// We need to let the window manager handle the Do window before popping up the
// preferences menu so that it can place the menu over the top.
GdkWindow.OverrideRedirect = false;
Services.Windowing.ShowMainMenu(global_point.X, global_point.Y);
// Have to re-grab the pane from the menu.
Interface.Windowing.PresentWindow(this);
GdkWindow.OverrideRedirect = true;
break;
}
return(base.OnButtonPressEvent(evnt));
}
private bool DragUpdate()
{
if (!dragging)
{
return(false);
}
if (!rotate)
{
return(MoveWindow());
}
else
{
Gdk.Point initial = start_root;
Gdk.Point hot = start_hot;
Gdk.Point win = Gdk.Point.Zero;
hot.X += win.X;
hot.Y += win.Y;
initial.X -= hot.X;
initial.Y -= hot.Y;
Gdk.Point now = root_pos;
now.X -= hot.X;
now.Y -= hot.Y;
Vector v1 = new Vector(initial);
Vector v2 = new Vector(now);
double angle = Vector.AngleBetween(v1, v2);
Angle = start_angle + angle;
return(false);
}
}
void HandleImageViewMotion(object sender, MotionNotifyEventArgs args)
{
Gdk.Point coords;
coords = new Gdk.Point((int)args.Event.X, (int)args.Event.Y);
SetSamplePoint(view.WindowCoordsToImage(coords));
}
private void RefreshMasterBehavior(MasterBehaviorType masterBehaviorType)
{
int detailWidthRequest = 0;
Gdk.Point point = default(Gdk.Point);
switch (_masterBehaviorType)
{
case MasterBehaviorType.Split:
detailWidthRequest = _lastAllocation.Width - DefaultMasterWidth;
point = new Gdk.Point(_master.WidthRequest, 0);
break;
case MasterBehaviorType.Default:
case MasterBehaviorType.Popover:
detailWidthRequest = _lastAllocation.Width;
point = new Gdk.Point(0, 0);
break;
}
if (detailWidthRequest >= 0)
{
_detail.WidthRequest = detailWidthRequest;
_detail.MoveTo(point.X, point.Y);
}
}
bool DragUpdate()
{
if (!dragging)
{
return(false);
}
if (!rotate)
{
return(MoveWindow());
}
var initial = start_root;
var hot = start_hot;
Gdk.Point win = Gdk.Point.Zero;
hot.X += win.X;
hot.Y += win.Y;
initial.X -= hot.X;
initial.Y -= hot.Y;
var now = root_pos;
now.X -= hot.X;
now.Y -= hot.Y;
var v1 = new Vector(initial.X, initial.Y);
var v2 = new Vector(now.X, now.Y);
double angleBetween = Vector.AngleBetween(v1, v2);
Angle = start_angle + angleBetween;
return(false);
}
protected override void encoderCapturePointsAdaptativeDisplay()
{
//adaptative displayed height
//if points go outside the graph, duplicate size of graph
if (
EncoderCapturePoints[i].Y > heightG || EncoderCapturePoints[i].Y <0 ||
EncoderCapturePointsInertialDisc[i].Y> heightG ||
EncoderCapturePointsInertialDisc[i].Y < 0)
{
realHeightG *= 2;
double sum2 = 0;
double sum2InertialDisc = 0;
for (int j = 0; j <= i; j++)
{
sum2 += encoderReaded[j];
sum2InertialDisc += encoderReadedInertialDisc[j];
EncoderCapturePoints[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / recordingTime),
Convert.ToInt32((heightG / 2) - (sum2 * heightG / realHeightG))
);
EncoderCapturePointsInertialDisc[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / recordingTime),
Convert.ToInt32((heightG / 2) - (sum2InertialDisc * heightG / realHeightG))
);
}
EncoderCapturePointsCaptured = i;
EncoderCapturePointsPainted = -1; //mark meaning screen should be erased and start painting from the beginning
}
}
//on inertial also assigns to EncoderCapturePointsInertialDisc
protected virtual void assignEncoderCapturePoints()
{
EncoderCapturePoints[i] = new Gdk.Point(
Convert.ToInt32(widthG * i / recordingTime),
Convert.ToInt32((heightG / 2) - (sum * heightG / realHeightG))
);
}
public Gdk.Point WindowCoordsToImage(Gdk.Point win)
{
Gdk.Point img;
f_image_view_window_coords_to_image(Handle, win.X, win.Y, out img.X, out img.Y);
return(img);
}
public void Redo()
{
for (int i = 0; i < NumCaptured; i++)
{
Points[i] = new Gdk.Point(GetTimeInPx(times[i]), GetForceInPx(forces[i]));
}
}
public PointLocation GetPointLocation(Gdk.Rectangle drawing_area, Gdk.Point point)
{
if (drawing_area.Contains(point))
{
return(PointLocation.Window);
}
return(PointLocation.Outside);
}
public void ShowPopup(Xwt.Rectangle onScreenArea, PopupPosition position)
{
this.parent = IdeApp.Workbench.RootWindow;
this.currentCaret = new Rectangle((int)onScreenArea.X, (int)onScreenArea.Y, (int)onScreenArea.Width, (int)onScreenArea.Height);
Theme.TargetPosition = position;
targetWindowOrigin = new Point((int)onScreenArea.X, (int)onScreenArea.Y);
RepositionWindow();
}
public PointLocation GetPointLocation(Gdk.Point point)
{
if (BackgroundRenderer.GetPointLocation(drawing_area, point) == PointLocation.Outside)
{
return(PointLocation.Outside);
}
return(TitleBarRenderer.GetPointLocation(drawing_area, point));
}
/// <summary>
/// Enmarca una imagen.
/// </summary>
/// <param name="image">
/// La imagen a enmarcar.
/// </param>
/// <param name="pos">
/// La esquina de la zona a recortar.
/// </param>
/// <param name="size">
/// El tamaño de la zona a recortar.
/// </param>
protected void GetEdges(FloatBitmap image, out Point pos, out Size size)
{
pos = new Point(0,0);
size = new Size(image.Width, image.Height);
bool found =false;
for(int i = 0; i < image.Width && !found; i++)
{
for(int j = 0; j < image.Height && !found; j++)
{
if (image[i, j] != FloatBitmap.White)
{
pos.X = i-1;
found = true;
}
}
}
found =false;
for(int i = image.Width-1; i >=0 && !found; i--)
{
for(int j = 0; j < image.Height && !found; j++)
{
if (image[i, j] != FloatBitmap.White)
{
size.Width = i - pos.X +2 ;
found = true;
}
}
}
found =false;
for(int j = 0; j < image.Height && !found; j++)
{
for(int i = 0; i < image.Width&& !found; i++)
{
if (image[i, j] != FloatBitmap.White)
{
pos.Y = j-1;
found = true;
}
}
}
found =false;
for(int j = image.Height-1; j >=0 && !found; j--)
{
for(int i = 0; i < image.Width && !found; i++)
{
if (image[i, j] != FloatBitmap.White)
{
size.Height = j - pos.Y +2;
found = true;
}
}
}
}
public void RenderItem(Context cr, Gdk.Point renderAnchor, int width, Do.Universe.Item item, bool drawArrow)
{
cr.Rectangle(renderAnchor.X, renderAnchor.Y, width, Height);
cr.SetSourceRGBA(0, 0, 0, 0);
cr.Operator = Operator.Source;
cr.Fill();
cr.Operator = Operator.Over;
Gdk.Pixbuf pixbuf = IconProvider.PixbufFromIconName(item.Icon, IconSize);
Gdk.CairoHelper.SetSourcePixbuf(cr, pixbuf, 2, 2);
cr.Paint();
pixbuf.Dispose();
foreach (int i in parent.Secondary)
{
if (parent.Results[i] == item)
{
pixbuf = IconProvider.PixbufFromIconName("gtk-add", IconSize);
Gdk.CairoHelper.SetSourcePixbuf(cr, pixbuf, 2, 2);
cr.PaintWithAlpha(.7);
pixbuf.Dispose();
}
}
Pango.Layout layout = new Pango.Layout(parent.PangoContext);
layout.Width = Pango.Units.FromPixels(width - IconSize - 25);
layout.Ellipsize = Pango.EllipsizeMode.End;
layout.SetMarkup("<span foreground=\"#" + parent.ItemTextColor + "\">" + GLib.Markup.EscapeText(item.Name) + "</span>");
layout.FontDescription = Pango.FontDescription.FromString("normal bold");
layout.FontDescription.AbsoluteSize = Pango.Units.FromPixels(10);
cr.MoveTo(IconSize + 6, 4);
Pango.CairoHelper.ShowLayout(cr, layout);
layout.SetMarkup("<span foreground=\"#" + parent.ItemTextColor + "\">" + GLib.Markup.EscapeText(item.Description) + "</span>");
layout.FontDescription.Dispose();
layout.FontDescription = Pango.FontDescription.FromString("normal");
layout.FontDescription.AbsoluteSize = Pango.Units.FromPixels(10);
cr.MoveTo(IconSize + 8, 19);
Pango.CairoHelper.ShowLayout(cr, layout);
if (drawArrow)
{
cr.MoveTo(width - 15, 13);
cr.LineTo(width - 15 + 7, 17);
cr.LineTo(width - 15, 21);
Gdk.Color gc = new Gdk.Color();
Gdk.Color.Parse("#" + parent.ItemTextColor, ref gc);
cr.SetSourceRGB(gc);
cr.Fill();
}
layout.FontDescription.Dispose();
layout.Dispose();
(cr as IDisposable).Dispose();
}
private unsafe void RenderPixelGrid(Cairo.ImageSurface dst, Gdk.Point offset)
{
EnsureLookupTablesCreated();
// Draw horizontal lines
var dst_ptr = (ColorBgra *)dst.DataPtr;
int dstHeight = dst.Height;
int dstWidth = dst.Width;
int dstStride = dst.Stride;
int sTop = d2sLookupY[offset.Y];
int sBottom = d2sLookupY[offset.Y + dstHeight];
for (int srcY = sTop; srcY <= sBottom; ++srcY)
{
int dstY = s2dLookupY[srcY];
int dstRow = dstY - offset.Y;
if (dstRow >= 0 && dstRow < dstHeight)
{
ColorBgra *dstRowPtr = dst.GetRowAddressUnchecked(dst_ptr, dstWidth, dstRow);
ColorBgra *dstRowEndPtr = dstRowPtr + dstWidth;
dstRowPtr += offset.X & 1;
while (dstRowPtr < dstRowEndPtr)
{
*dstRowPtr = ColorBgra.Black;
dstRowPtr += 2;
}
}
}
// Draw vertical lines
int sLeft = d2sLookupX[offset.X];
int sRight = d2sLookupX[offset.X + dstWidth];
for (int srcX = sLeft; srcX <= sRight; ++srcX)
{
int dstX = s2dLookupX[srcX];
int dstCol = dstX - offset.X;
if (dstCol >= 0 && dstCol < dstWidth)
{
byte *dstColPtr = (byte *)dst.GetPointAddress(dstCol, 0);
byte *dstColEndPtr = dstColPtr + dstStride * dstHeight;
dstColPtr += (offset.Y & 1) * dstStride;
while (dstColPtr < dstColEndPtr)
{
*((ColorBgra *)dstColPtr) = ColorBgra.Black;
dstColPtr += 2 * dstStride;
}
}
}
}
protected override void inertialCheckIfInverted()
{
/*
* 1) on inertial, when we start we should go down (because exercise starts in full extension)
* if at the beginning we detect movement as positive means that the encoder is connected backwards or
* the disc is in a position that makes the start in that direction
* we use the '20' to detect when 'some' movement has been done
* Just -1 all the past and future values of this capture
* (we use the 'sum > 0' to know that it's going upwards)
*
* 2) here sum == sumInertialDisc and encoderReaded == encoderReadedInertialDisc
* because this variables change later (when sum < -25 )
*/
if (Math.Abs(sum) > 20)
{
inertialShouldCheckStartDirection = false;
if (sum > 0)
{
inertialCaptureDirectionInverted = true;
byteReaded *= -1;
directionNow *= -1;
directionLastMSecond *= -1;
sum *= -1;
sumInertialDisc *= -1;
int xWidth = recordingTime;
if (cont)
{
xWidth = recordedTimeCont;
}
for (int j = 0; j <= i; j++)
{
encoderReaded[j] *= -1;
encoderReadedInertialDisc[j] *= -1;
}
double sum2 = 0;
for (int j = 0; j <= i; j++)
{
sum2 += encoderReaded[j];
EncoderCapturePoints[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / xWidth),
Convert.ToInt32((heightG / 2) - (sum2 * heightG / realHeightG))
);
//same for InertialDisc. Read comment 2 on the top of this method
EncoderCapturePointsInertialDisc[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / xWidth),
Convert.ToInt32((heightG / 2) - (sum2 * heightG / realHeightG))
);
}
EncoderCapturePointsCaptured = i;
EncoderCapturePointsPainted = -1; //mark meaning screen should be erased
}
}
}
void HandleCursorPositionChanged(object sender, CursorPostionChangedArgs e)
{
Gdk.Point cursor = Owner.CursorTracker.Cursor;
int monitor = Owner.Screen.GetMonitorAtPoint(cursor.X, cursor.Y);
Gdk.Rectangle geo = Owner.Screen.GetMonitorGeometry(monitor);
int activeRegion = Math.Min(geo.Height / 3, geo.Width / 3);
Gdk.Rectangle left = new Gdk.Rectangle(geo.X, geo.Y + activeRegion, activeRegion, geo.Height - activeRegion * 2);
Gdk.Rectangle top = new Gdk.Rectangle(geo.X + activeRegion, geo.Y, geo.Width - activeRegion * 2, activeRegion);
Gdk.Rectangle right = new Gdk.Rectangle(geo.X + geo.Width - activeRegion, geo.Y + activeRegion, activeRegion, geo.Height - activeRegion * 2);
Gdk.Rectangle bottom = new Gdk.Rectangle(geo.X + activeRegion, geo.Y + geo.Height - activeRegion, geo.Width - activeRegion * 2, activeRegion);
DockPosition target;
if (top.Contains(cursor))
{
target = DockPosition.Top;
}
else if (bottom.Contains(cursor))
{
target = DockPosition.Bottom;
}
else if (left.Contains(cursor))
{
target = DockPosition.Left;
}
else if (right.Contains(cursor))
{
target = DockPosition.Right;
}
else
{
return;
}
IDockPreferences prefs = Owner.Preferences;
if (prefs.Position != target || prefs.MonitorNumber != monitor)
{
Dock d = Docky.Controller.DocksForMonitor(monitor).FirstOrDefault(dock => dock.Preferences.Position == target);
if (d == null)
{
prefs.MonitorNumber = monitor;
prefs.Position = target;
}
else
{
d.Preferences.MonitorNumber = prefs.MonitorNumber;
d.Preferences.Position = prefs.Position;
prefs.MonitorNumber = monitor;
prefs.Position = target;
}
}
}
internal void ShowPopup(Xwt.Widget widget, Xwt.Rectangle caret, PopupPosition position)
{
xwtParent = widget;
this.currentCaret = new Gdk.Rectangle((int)caret.X, (int)caret.Y, (int)caret.Width, (int)caret.Height);
Theme.TargetPosition = position;
var pos = GtkUtil.GetSceenBounds(widget);
targetWindowOrigin = new Point((int)pos.X, (int)pos.Y);
RepositionWindow();
}
public PointLocation GetPointLocation(Gdk.Rectangle drawing_area, Gdk.Point point)
{
Gdk.Rectangle pref_circle = new Gdk.Rectangle(drawing_area.X + drawing_area.Width - 32,
drawing_area.Y + 5, 15, 15);
if (pref_circle.Contains(point))
{
return(PointLocation.Preferences);
}
return(PointLocation.Window);
}
public void Render(List <Layer> layers, Cairo.ImageSurface dst, Gdk.Point offset)
{
dst.Flush();
// Our rectangle of interest
var r = new Gdk.Rectangle(offset, dst.GetBounds().Size).ToCairoRectangle();
using (var g = new Cairo.Context(dst)) {
// Create the transparent checkerboard background
g.Translate(-offset.X, -offset.Y);
g.FillRectangle(r, tranparent_pattern, new Cairo.PointD(offset.X, offset.Y));
for (var i = 0; i < layers.Count; i++)
{
var layer = layers[i];
// If we're in LivePreview, substitute current layer with the preview layer
if (layer == PintaCore.Layers.CurrentLayer && PintaCore.LivePreview.IsEnabled)
{
layer = CreateLivePreviewLayer(layer);
}
// If the layer is offset, handle it here
if (!layer.Transform.IsIdentity())
{
layer = CreateOffsetLayer(layer);
}
// No need to resize the surface if we're at 100% zoom
if (scale_factor.Ratio == 1)
{
layer.Draw(g, layer.Surface, layer.Opacity, false);
}
else
{
using (var scaled = new Cairo.ImageSurface(Cairo.Format.Argb32, dst.Width, dst.Height)) {
g.Save();
// Have to undo the translate set above
g.Translate(offset.X, offset.Y);
CopyScaled(layer.Surface, scaled, r.ToGdkRectangle());
layer.Draw(g, scaled, layer.Opacity, false);
g.Restore();
}
}
}
}
// If we are at least 200% and grid is requested, draw it
if (enable_pixel_grid && PintaCore.Actions.View.PixelGrid.Active && scale_factor.Ratio <= 0.5d)
{
RenderPixelGrid(dst, offset);
}
dst.MarkDirty();
}
protected override void assignEncoderCapturePoints()
{
EncoderCapturePoints[i] = new Gdk.Point(
Convert.ToInt32(widthG * i / recordingTime),
Convert.ToInt32((heightG / 2) - (sum * heightG / realHeightG))
);
EncoderCapturePointsInertialDisc[i] = new Gdk.Point(
Convert.ToInt32(widthG * i / recordingTime),
Convert.ToInt32((heightG / 2) - (sumInertialDisc * heightG / realHeightG))
);
}
void OnCursorPositionChanged(Gdk.Point oldPoint)
{
if (CursorPositionChanged != null)
{
CursorPostionChangedArgs args = new CursorPostionChangedArgs {
LastPosition = oldPoint,
};
CursorPositionChanged(this, args);
}
}
//when we click our mouse button
void DragStart(object sender, Gtk.ButtonPressEventArgs args)
{
// single click
if (args.Event.Type == EventType.ButtonPress)
{
mouseStart = new Gdk.Point((int)Math.Floor(args.Event.X), (int)Math.Floor(args.Event.Y));
Console.WriteLine("-------------------------------------");
Console.WriteLine("Mouse Clicked");
Console.WriteLine("Mouse Start Point: ({0}, {1})", mouseStart.X, mouseStart.Y);
Console.WriteLine("-------------------------------------");
}
}
Gdk.Point [] Interpolate(int width, int height)
{
var vector = GetVector(width);
var retval = new Gdk.Point [width];
for (int i = 0; i < width; i++)
{
retval[i].X = x_offset + i;
retval[i].Y = y_offset + height - Project(vector[i], MinY, MaxY, height);
}
return(retval);
}
public void SetSurfaceAtPoint(DockySurface surface, Gdk.Point point)
{
if (surface == currentSurface && point == currentPoint)
{
window.QueueDraw();
return;
}
ResetBackgroundBuffer();
currentSurface = surface;
currentPoint = point;
if (surface == null)
{
Hide();
return;
}
window.SetSizeRequest(surface.Width, surface.Height);
Gdk.Point center = Gdk.Point.Zero;
int padding = 5;
switch (Gravity)
{
case DockPosition.Top:
center = new Gdk.Point(point.X - surface.Width / 2, point.Y + padding);
break;
case DockPosition.Left:
center = new Gdk.Point(point.X + padding, point.Y - surface.Height / 2);
break;
case DockPosition.Right:
center = new Gdk.Point(point.X - surface.Width - padding, point.Y - surface.Height / 2);
break;
case DockPosition.Bottom:
center = new Gdk.Point(point.X - surface.Width / 2, point.Y - surface.Height - padding);
break;
}
Gdk.Rectangle monitor_geo = window.Screen.GetMonitorGeometry(Monitor);
center.X = Math.Max(monitor_geo.X, Math.Min(center.X, monitor_geo.X + monitor_geo.Width - surface.Width));
center.Y = Math.Max(monitor_geo.Y, Math.Min(center.Y, monitor_geo.Y + monitor_geo.Height - surface.Height));
if (Visible)
{
window.QueueDraw();
}
window.Move(center.X, center.Y);
}
public override void FillPolygon(Color c, List <Point> points)
{
Gdk.Point[] pointArray = new Gdk.Point[points.Count];
for (int i = 0; i < points.Count; ++i)
{
pointArray[i].X = (int)points[i].X;
pointArray[i].Y = (int)points[i].Y;
}
Gdk.GC g = new Gdk.GC(window);
g.RgbFgColor = GdkColor(c);
window.DrawPolygon(g, true, pointArray);
}
public DragHandler(Gtk.Widget widget, Func<Gdk.Point[], IEnumerator> generator)
{
var p = new Gdk.Point[2];
IEnumerator coroutine = null;
widget.ButtonPressEvent += (o, args) => {
p [0] = new Gdk.Point ((int)args.Event.X, (int)args.Event.Y);
coroutine = generator(p);
if(!coroutine.MoveNext()) coroutine = null;
};
widget.MotionNotifyEvent += (o, args) => {
if(coroutine != null){
p[1] = new Gdk.Point ((int)args.Event.X, (int)args.Event.Y);
if(!coroutine.MoveNext()) coroutine = null;
}
};
//escape from coroutine
widget.ButtonReleaseEvent += (o, args) => coroutine = null;
}
private void DrawSelectionRect (Gtk.Widget widget, Gdk.Window window) {
Gdk.GC gc = (widget.Style.WhiteGC);
gc.SetLineAttributes (1,LineStyle.OnOffDash, CapStyle.Butt, JoinStyle.Miter);
gc.Function = Function.Xor;
_selectionRect.Normalize ();
Gdk.Point[] points = new Gdk.Point[4];
points [0] = new Gdk.Point((int)_selectionRect.X, (int)_selectionRect.Y);
points [1] = new Gdk.Point((int)_selectionRect.X2, (int)_selectionRect.Y);
points [2] = new Gdk.Point((int)_selectionRect.X2, (int)_selectionRect.Y2);
points [3] = new Gdk.Point((int)_selectionRect.X, (int)_selectionRect.Y2);
window.DrawPolygon(gc, false, points);
}
public void SetSurfaceAtPoint (DockySurface surface, Gdk.Point point)
{
if (surface == currentSurface && point == currentPoint) {
window.QueueDraw ();
return;
}
ResetBackgroundBuffer ();
currentSurface = surface;
currentPoint = point;
if (surface == null) {
Hide ();
return;
}
window.SetSizeRequest (surface.Width, surface.Height);
Gdk.Point center = Gdk.Point.Zero;
int padding = 5;
switch (Gravity) {
case DockPosition.Top:
center = new Gdk.Point (point.X - surface.Width / 2, point.Y + padding);
break;
case DockPosition.Left:
center = new Gdk.Point (point.X + padding, point.Y - surface.Height / 2);
break;
case DockPosition.Right:
center = new Gdk.Point (point.X - surface.Width - padding, point.Y - surface.Height / 2);
break;
case DockPosition.Bottom:
center = new Gdk.Point (point.X - surface.Width / 2, point.Y - surface.Height - padding);
break;
}
Gdk.Rectangle monitor_geo = window.Screen.GetMonitorGeometry (Monitor);
center.X = Math.Max (monitor_geo.X, Math.Min (center.X, monitor_geo.X + monitor_geo.Width - surface.Width));
center.Y = Math.Max (monitor_geo.Y, Math.Min (center.Y, monitor_geo.Y + monitor_geo.Height - surface.Height));
if (Visible)
window.QueueDraw ();
window.Move (center.X, center.Y);
}
private void GdkDraw(EventExpose evnt,int height,int width)
{
Time time = new Time();
layout.SetMarkup("0");
this.GdkWindow.DrawLayout(this.Style.TextGC(StateType.Normal),0,height-23,layout);
Gdk.Point topL= new Gdk.Point((int)(CurrentFrame/pixelRatio-Scroll-5),height-15);
Gdk.Point topR= new Gdk.Point((int)(CurrentFrame/pixelRatio-Scroll+5),height-15);
Gdk.Point bottom= new Gdk.Point((int)(CurrentFrame/pixelRatio-Scroll),height);
this.GdkWindow.DrawPolygon(this.Style.TextGC(StateType.Normal),true,new Gdk.Point[] {topL,topR,bottom});
for(int i=10*FrameRate; i<=frames/pixelRatio;) {
// Drawing separator line
evnt.Window.DrawLine(Style.DarkGC(StateType.Normal),i-(int)Scroll,height,i-(int)Scroll,height-10);
time.Seconds = (int)(i/FrameRate*pixelRatio);
layout.SetMarkup(time.ToSecondsString());
this.GdkWindow.DrawLayout(this.Style.TextGC(StateType.Normal),i-(int)Scroll-13,height-23,layout);
//g.ShowText(time.ToSecondsString());
i=i+10*FrameRate;
}
for(int i=0; i<=frames/pixelRatio;) {
evnt.Window.DrawLine(Style.DarkGC(StateType.Normal),i-(int)Scroll,height,i-(int)Scroll,height-5);
i=i+FrameRate;
}
// Drawing main line
evnt.Window.DrawLine(Style.DarkGC(StateType.Normal),0,height,width,height);
}
public static Point TransformOrientation(int total_width, int total_height, Point args, ImageOrientation orientation)
{
Point p = args;
switch (orientation) {
default:
case ImageOrientation.TopLeft:
break;
case ImageOrientation.TopRight:
p.X = total_width - p.X;
break;
case ImageOrientation.BottomRight:
p.X = total_width - p.X;
p.Y = total_height - p.Y;
break;
case ImageOrientation.BottomLeft:
p.Y = total_height - p.Y;
break;
case ImageOrientation.LeftTop:
p.X = args.Y;
p.Y = args.X;
break;
case ImageOrientation.RightTop:
p.X = total_height - args.Y;
p.Y = args.X;
break;
case ImageOrientation.RightBottom:
p.X = total_height - args.Y;
p.Y = total_width - args.X;
break;
case ImageOrientation.LeftBottom:
p.X = args.Y;
p.Y = total_width - args.X;
break;
}
return p;
}
/// <summary>
/// Updates drawing regions for the supplied surface
/// </summary>
/// <param name="surface">
/// The <see cref="DockySurface"/> surface off which the coordinates will be based
/// </param>
void UpdateDrawRegionsForSurface (DockySurface surface)
{
// first we do the math as if this is a top dock, to do this we need to set
// up some "pretend" variables. we pretend we are a top dock because 0,0 is
// at the top.
int width = surface.Width;
int height = surface.Height;
double zoom;
Gdk.Point cursor = LocalCursor;
Gdk.Point localCursor = cursor;
// "relocate" our cursor to be on the top
switch (Position) {
case DockPosition.Right:
cursor.X = (Width - 1) - cursor.X;
break;
case DockPosition.Bottom:
cursor.Y = (Height - 1) - cursor.Y;
break;
default:
break;
}
if (Preferences.IsVertical) {
int tmpY = cursor.Y;
cursor.Y = cursor.X;
cursor.X = tmpY;
// our width and height switch around if we have a veritcal dock
width = surface.Height;
height = surface.Width;
}
// this offset is used to split the icons into left/right aligned for panel mode
double panelanim = PanelModeToggleProgress;
int panel_item_offset;
if (Preferences.IsVertical)
panel_item_offset = (monitor_geo.Height - DockWidth) / 2;
else
panel_item_offset = (monitor_geo.Width - DockWidth) / 2;
if (panelanim >= 1) {
if (!Preferences.PanelMode)
panel_item_offset = 0;
} else {
if (Preferences.PanelMode)
panel_item_offset = (int) (panel_item_offset * panelanim);
else
panel_item_offset -= (int) (panel_item_offset * panelanim);
}
// the line along the dock width about which the center of unzoomed icons sit
int midline = DockHeight / 2;
// the left most edge of the first dock item
int startX = ((width - DockWidth) / 2) + DockWidthBuffer - panel_item_offset;
Gdk.Point center = new Gdk.Point (startX, midline);
// right align docklets
bool rightAlign = (Items [0].Owner != Preferences.DefaultProvider && Items [0] != DockyItem);
if (rightAlign)
center.X += 2 * panel_item_offset;
int index = 0;
foreach (AbstractDockItem adi in Items) {
// anything after the first separator is a docklet, and right aligned
if (!rightAlign && adi is SeparatorItem) {
rightAlign = true;
center.X += 2 * panel_item_offset;
}
// used to handle remove animations
if (remove_index != 0 && remove_index < index && remove_index > index - 1) {
double removePercent = 1 - Math.Min (1, (DateTime.UtcNow - remove_time).TotalMilliseconds / BaseAnimationTime.TotalMilliseconds);
if (removePercent == 0)
remove_index = 0;
else
center.X += (int) ((remove_size + ItemWidthBuffer) * removePercent);
}
DrawValue val = new DrawValue ();
int iconSize = IconSize;
// div by 2 may result in rounding errors? Will this render OK? Shorts WidthBuffer by 1?
double halfSize = iconSize / 2.0;
if (!adi.Square) {
DockySurface icon = adi.IconSurface (surface, iconSize, iconSize, VisibleDockHeight);
halfSize = ((adi.RotateWithDock || !Preferences.IsVertical) ? icon.Width : icon.Height) / 2.0;
}
// animate adding new icon
halfSize *= Math.Min (1, (DateTime.UtcNow - adi.AddTime).TotalMilliseconds / BaseAnimationTime.TotalMilliseconds);
// center now represents our midpoint
center.X += (int) Math.Floor (halfSize);
val.StaticCenter = new PointD (center.X, center.Y);
// get us some handy doubles with fancy names
double cursorPosition = cursor.X;
double centerPosition = center.X;
// ZoomPercent is a number greater than 1. It should never be less than one.
// zoomInPercent is a range of 1 to ZoomPercent.
// We need a number that is 1 when ZoomIn is 0, and ZoomPercent when ZoomIn is 1.
// Then we treat this as if it were the ZoomPercent for the rest of the calculation.
double zoomInPercent = 1 + (ZoomPercent - 1) * ZoomIn;
double zoomSize = ZoomEnabled ? ZoomedIconSize : 2.0 * IconSize;
// offset from the center of the true position, ranged between 0 and the zoom size
double offset = Math.Min (Math.Abs (cursorPosition - centerPosition), zoomSize);
double offsetPercent;
if (ExternalDragActive && DragTracker.ProviderAcceptsDrop ()) {
// Provide space for dropping between items
offset += offset * zoomSize / IconSize;
offsetPercent = Math.Min (1, offset / (zoomSize + ZoomedIconSize));
} else {
offsetPercent = offset / zoomSize;
}
if (offsetPercent > .99)
offsetPercent = 1;
// pull in our offset to make things less spaced out
// explaination since this is a bit tricky...
// we have three terms, basically offset = f(x) * h(x) * g(x)
// f(x) == offset identity
// h(x) == a number from 0 to DockPreference.ZoomPercent - 1. This is used to get the smooth "zoom in" effect.
// additionally serves to "curve" the offset based on the max zoom
// g(x) == a term used to move the ends of the zoom inward. Precalculated that the edges should be 66% of the current
// value. The center is 100%. (1 - offsetPercent) == 0,1 distance from center
// The .66 value comes from the area under the curve. Dont ask me to explain it too much because it's too clever for me.
// for external drags with no zoom, we pretend there is actually a zoom of 200%
if (ExternalDragActive && ZoomPercent == 1 && DragTracker.ProviderAcceptsDrop ())
offset *= ZoomIn / 2.0;
else
offset *= zoomInPercent - 1;
offset *= 1 - offsetPercent / 3;
if (cursorPosition > centerPosition)
centerPosition -= offset;
else
centerPosition += offset;
if (!adi.Zoom) {
val.Zoom = 1;
val.Center = new Cairo.PointD ((int) centerPosition, center.Y);
} else {
// zoom is calculated as 1 through target_zoom (default 2).
// The larger your offset, the smaller your zoom
// First we get the point on our curve that defines our current zoom
// offset is always going to fall on a point on the curve >= 0
zoom = 1 - Math.Pow (offsetPercent, 2);
// scale this to match our zoomInPercent
zoom = 1 + zoom * (zoomInPercent - 1);
double zoomedCenterHeight = DockHeightBuffer + (iconSize * zoom / 2.0);
if (zoom == 1)
centerPosition = Math.Round (centerPosition);
val.Center = new Cairo.PointD (centerPosition, zoomedCenterHeight);
val.Zoom = zoom;
}
// now we undo our transforms to the point
if (Preferences.IsVertical) {
double tmpY = val.Center.Y;
val.Center.Y = val.Center.X;
val.Center.X = tmpY;
tmpY = val.StaticCenter.Y;
val.StaticCenter.Y = val.StaticCenter.X;
val.StaticCenter.X = tmpY;
}
switch (Position) {
case DockPosition.Right:
val.Center.X = (height - 1) - val.Center.X;
val.StaticCenter.X = (height - 1) - val.StaticCenter.X;
break;
case DockPosition.Bottom:
val.Center.Y = (height - 1) - val.Center.Y;
val.StaticCenter.Y = (height - 1) - val.StaticCenter.Y;
break;
default:
break;
}
Gdk.Rectangle hoverArea = DrawRegionForItemValue (adi, val, true);
if (Preferences.IsVertical) {
hoverArea.Inflate ((int) (ZoomedDockHeight * .3), ItemWidthBuffer / 2);
hoverArea.Width += DockHeightBuffer;
} else {
hoverArea.Inflate (ItemWidthBuffer / 2, (int) (ZoomedDockHeight * .3));
hoverArea.Height += DockHeightBuffer;
}
switch (Position) {
case DockPosition.Right:
hoverArea.X -= DockHeightBuffer;
break;
case DockPosition.Bottom:
hoverArea.Y -= DockHeightBuffer;
break;
default:
break;
}
val.HoverArea = hoverArea;
DrawValues[adi] = val;
// keep the hovereditem in mind, but don't change it while rendering
if (hoverArea.Contains (localCursor) && !AutohideManager.Hidden && !(adi is SeparatorItem))
next_hoveredItem = adi;
if (update_screen_regions) {
if (Menu.Visible || ConfigurationMode || Painter != null) {
adi.SetScreenRegion (Screen, new Gdk.Rectangle (0, 0, 0, 0));
} else {
Gdk.Rectangle region = hoverArea;
region.X += window_position.X;
region.Y += window_position.Y;
adi.SetScreenRegion (Screen, region);
}
}
// move past midpoint to end of icon
center.X += (int) Math.Ceiling (halfSize) + ItemWidthBuffer;
index++;
}
update_screen_regions = false;
}
protected override void inertialCheckIfInverted()
{
/*
* 1) on inertial, when we start we should go down (because exercise starts in full extension)
* if at the beginning we detect movement as positive means that the encoder is connected backwards or
* the disc is in a position that makes the start in that direction
* we use the '20' to detect when 'some' movement has been done
* Just -1 all the past and future values of this capture
* (we use the 'sum > 0' to know that it's going upwards)
*
* 2) here sum == sumInertialDisc and encoderReaded == encoderReadedInertialDisc
* because this variables change later (when sum < -25 )
*/
if(Math.Abs(sum) > 20)
{
inertialShouldCheckStartDirection = false;
if(sum > 0) {
inertialCaptureDirectionInverted = true;
byteReaded *= -1;
directionNow *= -1;
directionLastMSecond *= -1;
sum *= -1;
sumInertialDisc *= -1;
int xWidth = recordingTime;
if(cont)
xWidth = recordedTimeCont;
for(int j=0; j <= i; j ++) {
encoderReaded[j] *= -1;
encoderReadedInertialDisc[j] *= -1;
}
double sum2=0;
for(int j=0; j <= i; j ++) {
sum2 += encoderReaded[j];
EncoderCapturePoints[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / xWidth),
Convert.ToInt32( (heightG/2) - ( sum2 * heightG / realHeightG) )
);
//same for InertialDisc. Read comment 2 on the top of this method
EncoderCapturePointsInertialDisc[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / xWidth),
Convert.ToInt32( (heightG/2) - ( sum2 * heightG / realHeightG) )
);
}
EncoderCapturePointsCaptured = i;
EncoderCapturePointsPainted = -1; //mark meaning screen should be erased
}
}
}
void HandleButtonPressEvent(object sender, ButtonPressEventArgs args)
{
switch (args.Event.Type) {
case EventType.ButtonPress:
if (args.Event.Button == 1) {
start = new Gdk.Point ((int)args.Event.X, (int)args.Event.Y);
start_root = new Gdk.Point ((int)args.Event.XRoot, (int)args.Event.YRoot);
start_hot = hotspot;
Gdk.Point win;
GdkWindow.GetOrigin (out win.X, out win.Y);
start_hot.X += win.X;
start_hot.Y += win.Y;
dragging = true;
rotate = (args.Event.State & ModifierType.ShiftMask) > 0;
start_angle = Angle;
} else {
Angle += Math.PI /8;
}
break;
case EventType.TwoButtonPress:
dragging = false;
App.Instance.Organizer.HideLoupe ();
break;
}
}
private static void GetPerpendicularCoords (int x,
int y,
double
sin,
double
cos,
int width,
out Gdk.
Point p1,
out Gdk.Point p2)
{
int alpha = width / 2;
p1 = new Gdk.Point ((int) Math.
Round (x + (alpha * sin)),
(int) Math.Round (y -
(alpha * cos)));
p2 = new Gdk.Point ((int) Math.
Round (x - (alpha * sin)),
(int) Math.Round (y +
(alpha * cos)));
}
public static void DrawArrow (Cairo.Context cairo,
Cairo.Color color, int x1,
int y1, int x2, int y2,
int size, bool filled)
{
double len =
Math.Sqrt ((y2 - y1) * (y2 - y1) +
(x2 - x1) * (x2 - x1));
double sin = (y2 - y1) / len;
double cos = (x2 - x1) / len;
int alpha = size / 4;
double line_portion = 0.75 * size / 2;
// the tip now touches the end of the square.
// computing it like this takes care of the direction
// from which the arrow is coming!
Gdk.Point tip = new Gdk.Point ((int) Math.
Round (x2 -
line_portion
* cos),
(int) Math.
Round (y2 -
line_portion
* sin));
x2 = tip.X;
y2 = tip.Y;
Gdk.Point[]a = new Gdk.Point[2];
GetPerpendicularCoords (x1, y1, sin, cos,
alpha, out a[0], out a[1]);
// This is the point where the arrow will start.
// We need to draw a rectangle from the above point to this.
// And the a triangle to the final dest.
double factor = 1.5;
Gdk.Point p =
new Gdk.Point ((int) Math.
Round (x2 -
factor * alpha *
cos),
(int) Math.Round (y2 -
factor
*
alpha
* sin));
Gdk.Point[]b = new Gdk.Point[2];
GetPerpendicularCoords (p.X, p.Y, sin, cos,
alpha, out b[0], out b[1]);
Gdk.Point c, d;
GetPerpendicularCoords (p.X, p.Y, sin, cos,
3 * alpha, out c, out d);
Gdk.Point[]points = new Gdk.Point[]
{
a[0], a[1], b[1], d, tip, c, b[0], a[0]};
/*
Cairo.Color color =
new Cairo.Color (0.5, 0.5, 0.8, 0.5);
*/
cairo.Color = color;
double orig = cairo.LineWidth;
double fraction = 5;
if (alpha > fraction)
cairo.LineWidth = alpha / fraction;
for (int i = 0; i < points.Length; i++)
{
if (i == 0)
cairo.MoveTo (points[i].X,
points[i].Y);
if (i == points.Length - 1)
cairo.LineTo (points[0].X,
points[0].Y);
else
cairo.LineTo (points[i + 1].
X, points[i + 1].Y);
}
cairo.FillPreserve ();
color.A = 0.8;
cairo.Color = color;
cairo.Stroke ();
cairo.LineWidth = orig;
}
internal void ShowPopup (Xwt.Widget widget, Xwt.Rectangle caret, PopupPosition position)
{
xwtParent = widget;
this.currentCaret = new Gdk.Rectangle ((int)caret.X, (int)caret.Y, (int)caret.Width, (int)caret.Height);
Theme.TargetPosition = position;
var pos = GtkUtil.GetSceenBounds (widget);
targetWindowOrigin = new Point ((int)pos.X, (int)pos.Y);
RepositionWindow ();
}
private int[] CreateS2DLookupY(int srcHeight, int dstHeight, ScaleFactor scaleFactor)
{
var lookup = new int[srcHeight + 1];
for (int y = 0; y < lookup.Length; ++y) {
Gdk.Point pt = new Gdk.Point (0, y);
Gdk.Point clientPt = scaleFactor.UnscalePoint (pt);
// Sometimes the scale factor is slightly different on one axis than
// on another, simply due to accuracy. So we have to clamp this value to
// be within bounds.
lookup[y] = Utility.Clamp (clientPt.Y, 0, dstHeight - 1);
}
return lookup;
}
private int[] CreateS2DLookupX(int srcWidth, int dstWidth, ScaleFactor scaleFactor)
{
var lookup = new int[srcWidth + 1];
for (int x = 0; x < lookup.Length; ++x) {
Gdk.Point pt = new Gdk.Point (x, 0);
Gdk.Point clientPt = scaleFactor.UnscalePoint (pt);
// Sometimes the scale factor is slightly different on one axis than
// on another, simply due to accuracy. So we have to clamp this value to
// be within bounds.
lookup[x] = Utility.Clamp (clientPt.X, 0, dstWidth - 1);
}
return lookup;
}
void ShowPopup (Gtk.Widget parent, Gdk.EventButton evt, Gdk.Rectangle caret, PopupPosition position)
{
this.parent = parent;
this.currentCaret = caret;
Theme.TargetPosition = position;
Gdk.Window targetWindow;
if (evt != null) {
eventProvided = true;
targetWindow = evt.Window;
} else
targetWindow = parent.GdkWindow;
if (targetWindow != null) {
int x, y;
targetWindow.GetOrigin (out x, out y);
targetWindowOrigin = new Point (x, y);
}
RepositionWindow ();
}
void HandleImageViewMotion(object sender, MotionNotifyEventArgs args)
{
Gdk.Point coords;
coords = new Gdk.Point ((int) args.Event.X, (int) args.Event.Y);
SetSamplePoint (view.WindowCoordsToImage (coords));
}
protected override void encoderCapturePointsAdaptativeDisplay()
{
//adaptative displayed height
//if points go outside the graph, duplicate size of graph
if(
EncoderCapturePoints[i].Y > heightG || EncoderCapturePoints[i].Y < 0 ||
EncoderCapturePointsInertialDisc[i].Y > heightG ||
EncoderCapturePointsInertialDisc[i].Y < 0 ) {
realHeightG *= 2;
int xWidth = recordingTime;
if(cont)
xWidth = recordedTimeCont;
double sum2 = 0;
double sum2InertialDisc = 0;
for(int j=0; j <= i; j ++) {
sum2 += encoderReaded[j];
sum2InertialDisc += encoderReadedInertialDisc[j];
EncoderCapturePoints[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / xWidth),
Convert.ToInt32( (heightG/2) - ( sum2 * heightG / realHeightG) )
);
EncoderCapturePointsInertialDisc[j] = new Gdk.Point(
Convert.ToInt32(widthG * j / xWidth),
Convert.ToInt32( (heightG/2) - ( sum2InertialDisc * heightG / realHeightG) )
);
}
EncoderCapturePointsCaptured = i;
EncoderCapturePointsPainted = -1; //mark meaning screen should be erased and start painting from the beginning
}
}
public void ShowPopup (Xwt.Rectangle onScreenArea, PopupPosition position)
{
this.parent = IdeApp.Workbench.RootWindow;
this.currentCaret = new Rectangle ((int)onScreenArea.X, (int)onScreenArea.Y, (int)onScreenArea.Width, (int)onScreenArea.Height);
Theme.TargetPosition = position;
targetWindowOrigin = new Point ((int)onScreenArea.X, (int)onScreenArea.Y);
RepositionWindow ();
}
internal void UpdateHoverText ()
{
int top = (int) (IconSize * (ZoomPercent + .2));
Gdk.Point point = new Gdk.Point (-1, -1);
DockySurface hover = null;
if (ActiveGlow) {
if (config_hover_buffer == null)
config_hover_buffer = DrawHoverText (config_hover_buffer, Catalog.GetString ("Drag to reposition"));
hover = config_hover_buffer;
top = IconSize + 2 * DockHeightBuffer;
} else if (hoveredItem != null && background_buffer != null) {
if (ExternalDragActive) {
if (DragTracker.ItemAcceptsDrop ()) {
if (launch_hover_buffer != null)
launch_hover_buffer.Dispose ();
launch_hover_buffer = DrawHoverText (launch_hover_buffer, hoveredItem.DropText);
hover = launch_hover_buffer;
} else if (DragTracker.ProviderAcceptsDrop ()) {
if (drop_hover_buffer == null)
drop_hover_buffer = DrawHoverText (drop_hover_buffer, Catalog.GetString ("Drop to add to dock"));
hover = drop_hover_buffer;
}
} else {
hover = hoveredItem.HoverTextSurface (background_buffer, Style, HoverTextManager.IsLight);
DrawValue loc = DrawValues[hoveredItem].MoveIn (Position, IconSize * (ZoomPercent + .1) - IconSize / 2);
point = new Gdk.Point ((int) loc.StaticCenter.X, (int) loc.StaticCenter.Y);
point.X += window_position.X;
point.Y += window_position.Y;
}
} else if (hoveredItem == null && ExternalDragActive && DragTracker.ProviderAcceptsDrop ()) {
if (drop_hover_buffer == null)
drop_hover_buffer = DrawHoverText (drop_hover_buffer, Catalog.GetString ("Drop to add to dock"));
hover = drop_hover_buffer;
} else {
return;
}
// default centers it on the dock
if (point.X == -1 && point.Y == -1) {
int offset = 8;
switch (Position) {
default:
case DockPosition.Top:
point = new Gdk.Point (window_position.X + Allocation.Width / 2, offset + window_position.Y + top);
break;
case DockPosition.Bottom:
point = new Gdk.Point (window_position.X + Allocation.Width / 2, window_position.Y + Allocation.Height - top - offset);
break;
case DockPosition.Left:
point = new Gdk.Point (offset + window_position.X + top, window_position.Y + Allocation.Height / 2);
break;
case DockPosition.Right:
point = new Gdk.Point (window_position.X + Allocation.Width - top - offset, window_position.Y + Allocation.Height / 2);
break;
}
}
TextManager.Gravity = Position; // FIXME
TextManager.Monitor = Monitor;
TextManager.SetSurfaceAtPoint (hover, point);
}
void Update (Gdk.Screen screen, int x, int y, Gdk.ModifierType mod)
{
last_update = DateTime.UtcNow;
if (!Enabled)
return;
Gdk.Point lastPostion = Cursor;
Cursor = new Gdk.Point (x, y);
Modifier = mod;
Screen = screen;
if (lastPostion != Cursor)
OnCursorPositionChanged (lastPostion);
}
private void updateEncoderCaptureGraphPaint(UpdateEncoderPaintModes mode)
{
if(eCapture.EncoderCapturePoints == null)
return;
//this happens when EncoderCaptureShowOnlyBars=TRUE
if(encoder_capture_signal_drawingarea == null || encoder_capture_signal_pixmap == null)
return;
bool refreshAreaOnly = false;
//mark meaning screen should be erased
if(eCapture.EncoderCapturePointsPainted == -1) {
UtilGtk.ErasePaint(encoder_capture_signal_drawingarea, encoder_capture_signal_pixmap);
eCapture.EncoderCapturePointsPainted = 0;
}
//also can be optimized to do not erase window every time and only add points since last time
int last = eCapture.EncoderCapturePointsCaptured;
int toDraw = eCapture.EncoderCapturePointsCaptured - eCapture.EncoderCapturePointsPainted;
//LogB.Information("last - toDraw:" + last + " - " + toDraw);
//fixes crash at the end
if(toDraw == 0)
return;
int maxY=-1;
int minY=10000;
Gdk.Point [] paintPoints = new Gdk.Point[toDraw];
Gdk.Point [] paintPointsInertial = new Gdk.Point[toDraw];
//currently disabled points painting on continuous mode
if(radio_encoder_capture_cont.Active) {
int graphWidth = encoder_capture_signal_drawingarea.Allocation.Width;
int graphHeight = encoder_capture_signal_drawingarea.Allocation.Height;
layout_encoder_capture_signal.SetMarkup("Graph currently disabled\non continuous mode");
int textWidth = 1;
int textHeight = 1;
layout_encoder_capture_signal.GetPixelSize(out textWidth, out textHeight);
encoder_capture_signal_pixmap.DrawLayout(pen_blue_encoder_capture,
graphWidth/2 - textWidth/2, graphHeight/2 - textHeight/2, layout_encoder_capture_signal);
}
else {
for(int j=0, i = eCapture.EncoderCapturePointsPainted +1 ; i <= last ; i ++, j++)
{
paintPoints[j] = eCapture.EncoderCapturePoints[i];
if(refreshAreaOnly) {
if(eCapture.EncoderCapturePoints[i].Y > maxY)
maxY = eCapture.EncoderCapturePoints[i].Y;
if(eCapture.EncoderCapturePoints[i].Y < minY)
minY = eCapture.EncoderCapturePoints[i].Y;
}
}
if(mode == UpdateEncoderPaintModes.INERTIAL) {
for(int j=0, i = eCapture.EncoderCapturePointsPainted +1 ; i <= last ; i ++, j ++)
{
//only assign the points if they are different than paintPoints
if(eCapture.EncoderCapturePointsInertialDisc[i] != eCapture.EncoderCapturePoints[i] &&
(i % 800) <= 520 //dashed accepting 520 points and discarding 280
) {
paintPointsInertial[j] = eCapture.EncoderCapturePointsInertialDisc[i];
if(refreshAreaOnly) {
if(eCapture.EncoderCapturePointsInertialDisc[i].Y > maxY)
maxY = eCapture.EncoderCapturePointsInertialDisc[i].Y;
if(eCapture.EncoderCapturePointsInertialDisc[i].Y < minY)
minY = eCapture.EncoderCapturePointsInertialDisc[i].Y;
}
}
}
encoder_capture_signal_pixmap.DrawPoints(pen_gray, paintPointsInertial);
}
//paint this after the inertial because this should mask the other
encoder_capture_signal_pixmap.DrawPoints(pen_black_encoder_capture, paintPoints);
}
//write title
string title = "";
if(mode == UpdateEncoderPaintModes.CALCULE_IM)
title = Catalog.GetString("Inertia M.");
else {
title = currentPerson.Name + " (";
if(encoderConfigurationCurrent.has_inertia)
title += encoderConfigurationCurrent.inertiaTotal.ToString() + " " + Catalog.GetString("Inertia M.") + ")";
else
title += findMass(Constants.MassType.EXTRA).ToString() + "Kg)";
}
layout_encoder_capture_signal.SetMarkup(title);
encoder_capture_signal_pixmap.DrawLayout(pen_blue_encoder_capture, 5, 5, layout_encoder_capture_signal);
if(refreshAreaOnly) {
/*
LogB.Information("pp X-TD-W: " +
paintPoints[0].X.ToString() + " - " +
paintPoints[toDraw-1].X.ToString() + " - " +
(paintPoints[toDraw-1].X-paintPoints[0].X).ToString());
*/
int startX = paintPoints[0].X;
/*
* this helps to ensure that no white points are drawed
* caused by this int when eCapture.EncoderCapturePoints are assigned:
* Convert.ToInt32(width*i/recordingTime)
*/
int exposeMargin = 4;
if(startX -exposeMargin > 0)
startX -= exposeMargin;
encoder_capture_signal_drawingarea.QueueDrawArea( // -- refresh
startX,
minY,
(paintPoints[toDraw-1].X-paintPoints[0].X ) + exposeMargin,
maxY-minY
);
//if refreshAreaOnly is true, then repeat above instruction for paintPointsInertial
LogB.Information("minY - maxY " + minY + " - " + maxY);
} else
encoder_capture_signal_drawingarea.QueueDraw(); // -- refresh
eCapture.EncoderCapturePointsPainted = eCapture.EncoderCapturePointsCaptured;
}
Gdk.Point[] Interpolate(int width, int height)
{
var vector = GetVector (width);
var retval = new Gdk.Point [width];
for (int i = 0; i < width; i++) {
retval[i].X = x_offset + i;
retval[i].Y = y_offset + height - Project (vector[i], MinY, MaxY, height);
}
return retval;
}