private void AssociatedObject_DragEnter(object sender, DragEventArgs e)
{
LayerDragData data = e.Data.GetData(typeof(LayerDragData)) as LayerDragData;
if (data != null)
{
IBImage trg = AssociatedObject.DataContext as IBImage;
if (trg == null || trg == data.from || trg.owner == null)
{
return;
}
CellSource trgOwner = trg.owner as CellSource;
if (trgOwner == null || trgOwner != data.fromOwner)
{
return;
}
int trgIndex = trgOwner.Layers.IndexOf(trg);
trgOwner.Layers.Remove(data.from);
trgOwner.Layers.Insert(trgIndex, data.from);
RedoUndoManager.Current.Record(new RUSortLayer(data.from, data.fromIndex, data.fromOwner, trg, trgIndex));
IBCanvasControl.RefreshAll();
}
}
private void AssociatedObject_MouseLeave(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
IBImage trg = AssociatedObject.DataContext as IBImage;
if (trg == null || trg.owner == null)
{
return;
}
CellSource trgOwner = trg.owner as CellSource;
if (trgOwner == null)
{
return;
}
LayerDragData data = new LayerDragData()
{
from = trg,
fromOwner = trgOwner,
fromIndex = trgOwner.Layers.IndexOf(trg)
};
DragDrop.DoDragDrop(AssociatedObject, data, DragDropEffects.Move);
}
}
public RUSortLayer(IBImage from, int fromIndex, CellSource owner, IBImage to, int toIndex)
{
From = from;
FromIndex = fromIndex;
Owner = owner;
To = to;
ToIndex = toIndex;
}
public static void DrawOneImage(IBImage i, double zoomPerCent, ref double layer)
{
if (!i.IsVisible)
{
return;
}
double zoom = zoomPerCent / 100.0;
double offsetX;
double offsetY;
double w, h;
if (i.LayerType != ImageTypes.SingleColor)
{
offsetX = (i.Rect.OffsetX + i.imageData.actualSize.OffsetX) * zoom;
offsetY = (i.Rect.OffsetY + (i.Rect.Height - i.imageData.actualSize.OffsetY - i.imageData.actualSize.Height)) * zoom;
w = i.imageData.actualSize.Width * zoom;
h = i.imageData.actualSize.Height * zoom;
}
else
{
offsetX = i.Rect.OffsetX * zoom;
offsetY = i.Rect.OffsetY * zoom;
w = i.Rect.Width * zoom;
h = i.Rect.Height * zoom;
}
double texMin = 0, texMax = 1.0;
if (i.LayerType == ImageTypes.SingleColor)
{
texMin = 0.5;
texMax = 0.5;
}
IBFramework.OpenGL.Texture.BindTexture(i.imageData.textureNumber);
{
GL.Begin(PrimitiveType.Quads);
{
GL.TexCoord2(texMax, texMin);
GL.Vertex3(offsetX + w, offsetY + h, layer);
GL.TexCoord2(texMin, texMin);
GL.Vertex3(offsetX, offsetY + h, layer);
GL.TexCoord2(texMin, texMax);
GL.Vertex3(offsetX, offsetY, layer);
GL.TexCoord2(texMax, texMax);
GL.Vertex3(offsetX + w, offsetY, layer);
}
GL.End();
layer += 0.01;
}
//IBFramework.OpenGL.Texture.BindTexture(0);
}
private void Draw(IBImage trg)
{
if (trg == null)
{
return;
}
double _x = curCoord.x - trg.Rect.OffsetX, _y = curCoord.y - trg.Rect.OffsetY;
double preX = histCoord[1].x - trg.Rect.OffsetX, preY = histCoord[1].y - trg.Rect.OffsetY;
double dx = curCoord.x - histCoord[1].x, dy = curCoord.y - histCoord[1].y;
double length = Math.Sqrt(dx * dx + dy * dy);
if (length > 200)
{
return;
}
double interval = 0.1 / length;
double t = last_t / length;
while (t < 1.0)
{
double x = preX + dx * t;
double y = preY + dy * t;
if (x < 0)
{
x = 0;
}
if (y < 0)
{
y = 0;
}
if (x >= trg.imageData.actualSize.Width)
{
x = trg.imageData.actualSize.Width - 1;
}
if (y >= trg.imageData.actualSize.Height)
{
y = trg.imageData.actualSize.Height - 1;
}
DrawPoint(trg, x, y);
t += 0.5 * interval;
}
last_t = length * (t - 1.0);
EntryTexUpdate(trg.imageData);
}
private void DrawToLineDrawingImage(IBImage trg, double r, PixelData color)
{
double _x = curCoord.x - trg.Rect.OffsetX, _y = curCoord.y - trg.Rect.OffsetY;
if (_x < 0 || _y < 0 || _x >= trg.imageData.actualSize.Width || _y >= trg.imageData.actualSize.Height)
{
return;
}
double preX = histCoord[1].x - trg.Rect.OffsetX, preY = histCoord[1].y - trg.Rect.OffsetY, prePre = histPressure[1];
double dx = curCoord.x - histCoord[1].x, dy = curCoord.y - histCoord[1].y, dp = curPressure - prePre;
double length = Math.Sqrt(dx * dx + dy * dy);
if (length > 200)
{
return;
}
double interval = 0.1 / length;
double t = last_t / length;
while (t < 1.0)
{
double x = preX + dx * t;
double y = preY + dy * t;
double p = prePre + dp * t;
if (p == 0)
{
DrawCircle(trg, x, y, r, color);
}
else if (p > 0.2)
{
double _r = r;
if (p != 0.0)
{
_r *= PenTouch(p);
}
DrawCircle(trg, x, y, _r, color);
}
t += r * interval;
}
last_t = length * (t - 1.0);
EntryTexUpdate(trg.imageData);
}
private void DrawPoint(IBImage trg, double x, double y)
{
int imageW = (int)trg.imageData.actualSize.Width;
int imageH = (int)trg.imageData.actualSize.Height;
byte[] data = trg.imageData.data;
int stride = imageW * 4;
RecordDrawArea((int)x, (int)y, (int)x, (int)y);
int offset = (int)y * stride;
int xp = (int)x * 4;
data[offset + xp + 2] = 255;
data[offset + xp + 3] = 255;
}
private void EndDrawing(IBImage trg)
{
double _x = curCoord.x - trg.Rect.OffsetX, _y = curCoord.y - trg.Rect.OffsetY;
double preX = start.x - trg.Rect.OffsetX, preY = start.y - trg.Rect.OffsetY;
double dx = curCoord.x - start.x, dy = curCoord.y - start.y;
double length = Math.Sqrt(dx * dx + dy * dy);
double interval = 0.1 / length;
double t = last_t / length;
while (t < 1.0)
{
double x = preX + dx * t;
double y = preY + dy * t;
if (x < 0)
{
x = 0;
}
if (y < 0)
{
y = 0;
}
if (x >= trg.imageData.actualSize.Width)
{
x = trg.imageData.actualSize.Width - 1;
}
if (y >= trg.imageData.actualSize.Height)
{
y = trg.imageData.actualSize.Height - 1;
}
DrawPoint(trg, x, y);
t += interval;
}
last_t = length * (t - 1.0);
EntryTexUpdate(trg.imageData);
}
public static void RenderCellSource(CellSource c, double zoomPerCent, ref double layer)
{
if (c == null)
{
return;
}
for (int index = c.Layers.Count - 1; index >= 0; index--)
{
IBImage i = c.Layers[index];
DrawOneImage(i, zoomPerCent, ref layer);
}
if (c.PixcelSelectedArea != null)
{
DrawPixcelSelectedLayer(c.PixcelSelectedArea, zoomPerCent, ref layer);
}
if (c.TempLayer != null)
{
DrawOneImage(c.TempLayer, zoomPerCent, ref layer);
}
}
public void AddNewLayer(string name, bool RURecord = true, ImageTypes type = ImageTypes.LineDrawing)
{
IBImage l = null;
switch (type)
{
case ImageTypes.Coloring:
case ImageTypes.LineDrawing:
l = new PixcelImage(Width + 300, Height + 300, -150, -150);
l.imageData.ClearData(new PixelData()
{
r = 255, g = 255, b = 255, a = 0
});
break;
case ImageTypes.SingleColor:
l = new SingleColorImage(255, 255, 255, 255);
l.Rect = new IBRectangle(1920 + 300, 1080 + 300, -150, -150);
break;
case ImageTypes.Pixel:
l = new PixcelImage();
break;
default:
break;
}
if (l == null)
{
return;
}
l.LayerName = name;
l.LayerType = type;
l.IsSelectedLayer = true;
l.owner = this;
l.imageData.TextureUpdate();
foreach (IBImage i in Layers)
{
if (i.IsSelectedLayer)
{
i.IsSelectedLayer = false;
int index = Layers.IndexOf(i);
Layers.Insert(index, l);
if (RURecord)
{
RedoUndoManager.Current.Record(new RUAddNewLayer(this, l));
}
return;
}
}
if (RURecord)
{
RedoUndoManager.Current.Record(new RUAddNewLayer(this, l));
}
Layers.Insert(0, l);
}
public RUAddNewLayer(CellSource owner, IBImage newLayer)
{
Owner = owner;
trgLayer = newLayer;
index = Owner.Layers.IndexOf(trgLayer);
}
private void EraseCircle(IBImage trg, double x, double y, double r)
{
if (r < 0.001)
{
return;
}
int imageW = (int)trg.imageData.actualSize.Width;
int imageH = (int)trg.imageData.actualSize.Height;
byte[] data = trg.imageData.data;
int stride = imageW * 4;
int xs = (int)Math.Floor(x - r);
int xe = (int)Math.Floor(x + r);
int ys = (int)Math.Floor(y - r);
int ye = (int)Math.Floor(y + r);
if (xs < 0)
{
xs = 0;
}
if (ys < 0)
{
ys = 0;
}
if (xe >= imageW)
{
xe = imageW - 1;
}
if (ye >= imageH)
{
ye = imageH - 1;
}
RecordDrawArea(xs, ys, xe, ye);
double r2 = r * r;
double sample = 4.0;
for (int yi = ys; yi <= ye; yi++)
{
int offset = yi * stride;
int xp = xs * 4;
for (int xi = xs; xi <= xe; xi++)
{
int c = 0;
for (int _yi = 0; _yi < sample; _yi++)
{
double yy = yi - y + _yi / sample;
for (int _xi = 0; _xi < sample; _xi++)
{
double xx = xi - x + _xi / sample;
if (xx * xx + yy * yy < r2)
{
c++;
}
}
}
if (c != 0)
{
//data[offset + xp] = color.b;
//data[offset + xp + 1] = color.g;
//data[offset + xp + 2] = color.r;
int a = data[offset + xp + 3] - ((255 * c) >> 4);
if (a < 0)
{
a = 0;
}
data[offset + xp + 3] = a < data[offset + xp + 3] ? (byte)a : data[offset + xp + 3];
}
xp += 4;
}
}
}
public override void CopyTo(IBImage i)
{
i = new PixcelImage();
base.CopyTo(i);
}
