BioCore  5.0.0
A Windows .NET microscopy library and application for viewing, editing, and annotating images.
Loading...
Searching...
No Matches
Classes | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Properties | List of all members
BioCore.Tools Class Reference
Inheritance diagram for BioCore.Tools:

Classes

class  Tool
 

Public Member Functions

 Tools ()
 
void UpdateOverlay ()
 
void UpdateView ()
 
void UpdateSelected ()
 
void ToolDown (PointD e, MouseButtons buts)
 
void ToolUp (PointD e, MouseButtons buts)
 
void ToolMove (PointD e, MouseButtons buts)
 

Static Public Member Functions

static Tool GetTool (string name)
 
static Tool GetTool (Tool.Type typ)
 

Public Attributes

Font font
 

Static Public Attributes

static bool applyToStack = false
 
static ColorTool colorTool
 
static bool rEnabled = true
 
static bool gEnabled = true
 
static bool bEnabled = true
 
static Rectangle selectionRectangle
 
static Hashtable tools = new Hashtable()
 
static Tool currentTool
 
static RectangleD selectionRect
 
static float selectBoxSize = ROI.selectBoxSize
 

Protected Member Functions

override void Dispose (bool disposing)
 Clean up any resources being used.
 

Properties

static ColorS DrawColor [get, set]
 
static ColorS EraseColor [get, set]
 
static int StrokeWidth [get, set]
 

Detailed Description

Definition at line 3 of file Tools.Designer.cs.

Constructor & Destructor Documentation

◆ Tools()

BioCore.Tools.Tools ( )

Definition at line 164 of file Tools.cs.

165 {
166 InitializeComponent();
167 Tool.Init();
168 ColorS col = new ColorS(ushort.MaxValue);
169 //We initialize the tools
170 currentTool = GetTool(Tool.Type.move);
171
172 floodFiller = null;
173 floodFiller = new QueueLinearFloodFiller(floodFiller);
174 }
BioCore.Tools.GetTool
static Tool GetTool(string name)
Definition Tools.cs:176
BioCore.Tools.currentTool
static Tool currentTool
Definition Tools.cs:124

Member Function Documentation

◆ Dispose()

override void BioCore.Tools.Dispose ( bool disposing)
protected

Clean up any resources being used.

Parameters
disposingtrue if managed resources should be disposed; otherwise, false.

Definition at line 14 of file Tools.Designer.cs.

15 {
16 if (disposing && (components != null))
17 {
18 components.Dispose();
19 }
20 base.Dispose(disposing);
21 }

◆ GetTool() [1/2]

static Tool BioCore.Tools.GetTool ( string name)
static

Definition at line 176 of file Tools.cs.

177 {
178 return (Tool)tools[name];
179 }
BioCore.Tools.tools
static Hashtable tools
Definition Tools.cs:31

◆ GetTool() [2/2]

static Tool BioCore.Tools.GetTool ( Tool.Type typ)
static

Definition at line 180 of file Tools.cs.

181 {
182 return (Tool)tools[typ.ToString()];
183 }

◆ ToolDown()

void BioCore.Tools.ToolDown ( PointD e,
MouseButtons buts )

The function is called when the user clicks the mouse button.
The function checks if the user is using the line, polygon, freeform, rectangle, ellipse, delete, or text tool.

If the user is using the line tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the polygon tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the freeform tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the rectangle tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the ellipse tool, the function creates a new ROI object and adds it to the image's annotations.

If

Parameters
PointDA point with double precision
MouseButtonsA set of values that indicate which mouse button was pressed.
Returns
The return type is void.

Definition at line 241 of file Tools.cs.

242 {
243 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null)
244 return;
245 Scripting.UpdateState(Scripting.State.GetDown(e, buts));
246 PointD p;
247 p = ImageView.SelectedImage.ToImageSpace(e);
248 if (currentTool.type == Tool.Type.line && buts == MouseButtons.Left)
249 {
250 if (anno.GetPointCount() == 0)
251 {
252 anno = new ROI();
253 anno.type = ROI.Type.Line;
254 anno.AddPoint(new PointD(e.X, e.Y));
255 anno.AddPoint(new PointD(e.X, e.Y));
256 anno.coord = App.viewer.GetCoordinate();
257 ImageView.SelectedImage.Annotations.Add(anno);
258 }
259 }
260 else
261 if (currentTool.type == Tool.Type.polygon && buts == MouseButtons.Left)
262 {
263 if (anno.GetPointCount() == 0)
264 {
265 anno = new ROI();
266 anno.type = ROI.Type.Polygon;
267 anno.AddPoint(new PointD(e.X, e.Y));
268 anno.coord = App.viewer.GetCoordinate();
269 ImageView.SelectedImage.Annotations.Add(anno);
270 }
271 else
272 {
273 //If we click on a point 1 we close this polygon
274 RectangleD d = new RectangleD(e.X, e.Y, ROI.selectBoxSize, ROI.selectBoxSize);
275 if (d.IntersectsWith(anno.Point))
276 {
277 anno.closed = true;
278 anno = new ROI();
279 }
280 else
281 {
282 anno.AddPoint(new PointD(e.X, e.Y));
283 }
284 }
285 }
286 else
287 if (currentTool.type == Tool.Type.freeform && buts == MouseButtons.Left)
288 {
289 if (anno.GetPointCount() == 0)
290 {
291 anno = new ROI();
292 anno.type = ROI.Type.Freeform;
293 anno.AddPoint(new PointD(e.X, e.Y));
294 anno.coord = App.viewer.GetCoordinate();
295 anno.closed = true;
296 ImageView.SelectedImage.Annotations.Add(anno);
297 }
298 else
299 {
300 anno.AddPoint(new PointD(e.X, e.Y));
301 }
302 }
303 else
304 if (currentTool.type == Tool.Type.rect && buts == MouseButtons.Left)
305 {
306 anno = ROI.CreateRectangle(App.viewer.GetCoordinate(),e.X,e.Y,1,1);
307 ImageView.SelectedImage.Annotations.Add(anno);
308 }
309 else
310 if (currentTool.type == Tool.Type.ellipse && buts == MouseButtons.Left)
311 {
312 anno = ROI.CreateRectangle(App.viewer.GetCoordinate(), e.X, e.Y, 1, 1);
313 ImageView.SelectedImage.Annotations.Add(anno);
314 }
315 else
316 if(currentTool.type == Tool.Type.delete && buts == MouseButtons.Left)
317 {
318 for (int i = 0; i < ImageView.SelectedImage.Annotations.Count; i++)
319 {
320 ROI an = ImageView.SelectedImage.Annotations[i];
321 if (an.BoundingBox.IntersectsWith(e.X,e.Y))
322 {
323 if (an.selectedPoints.Count == 0)
324 {
325 ImageView.SelectedImage.Annotations.Remove(an);
326 break;
327 }
328 else
329 if (an.selectedPoints.Count == 1 && !(an.type == ROI.Type.Polygon || an.type == ROI.Type.Polyline || an.type == ROI.Type.Freeform))
330 {
331 ImageView.SelectedImage.Annotations.Remove(an);
332 break;
333 }
334 else
335 {
336 if (an.type == ROI.Type.Polygon ||
337 an.type == ROI.Type.Polyline ||
338 an.type == ROI.Type.Freeform)
339 {
340 an.closed = false;
341 an.RemovePoints(an.selectedPoints.ToArray());
342 break;
343 }
344 }
345 }
346 }
347 UpdateOverlay();
348 }
349 else
350 if (currentTool.type == Tool.Type.text && buts == MouseButtons.Left)
351 {
352 ROI an = new ROI();
353 an.type = ROI.Type.Label;
354 an.AddPoint(new PointD(e.X, e.Y));
355 an.coord = App.viewer.GetCoordinate();
356 TextInput ti = new TextInput("");
357 if (ti.ShowDialog() != DialogResult.OK)
358 return;
359 an.family = ti.font.FontFamily.ToString();
360 an.fontSize = ti.font.Size;
361 an.strokeColor = AForge.Color.FromArgb(ti.color.A, ti.color.R, ti.color.G, ti.color.B);
362 an.Text = ti.TextValue;
363 ImageView.SelectedImage.Annotations.Add(an);
364 }
365 else
366 if (buts == MouseButtons.Middle || currentTool.type == Tool.Type.pan)
367 {
368 currentTool = GetTool(Tool.Type.pan);
369 UpdateSelected();
370 panPanel.BackColor = System.Drawing.Color.LightGray;
371 Cursor.Current = Cursors.Hand;
372 }
373
374 UpdateOverlay();
375 }
RectangleD
AForge.RectangleD RectangleD
Definition ImageView.cs:17
BioCore.Tools.UpdateOverlay
void UpdateOverlay()
Definition Tools.cs:184
BioCore.Tools.UpdateSelected
void UpdateSelected()
Definition Tools.cs:194

◆ ToolMove()

void BioCore.Tools.ToolMove ( PointD e,
MouseButtons buts )

Definition at line 535 of file Tools.cs.

536 {
537 if (App.viewer == null)
538 return;
539 Scripting.UpdateState(Scripting.State.GetMove(e, buts));
540 if (ImageView.SelectedImage == null)
541 return;
542 PointD p;
543 p = ImageView.SelectedImage.ToImageSpace(e);
544 if (currentTool.type == Tool.Type.line && ImageView.down)
545 {
546 anno.UpdatePoint(new PointD(e.X, e.Y), 1);
547 UpdateOverlay();
548 }
549 else
550 if (currentTool.type == Tool.Type.freeform && buts == MouseButtons.Left && ImageView.down)
551 {
552 if (anno.GetPointCount() == 0)
553 {
554 anno.type = ROI.Type.Freeform;
555 anno.AddPoint(new PointD(e.X, e.Y));
556 anno.coord = App.viewer.GetCoordinate();
557 anno.closed = true;
558 ImageView.SelectedImage.Annotations.Add(anno);
559 }
560 else
561 {
562 anno.AddPoint(new PointD(e.X, e.Y));
563 }
564 UpdateOverlay();
565 }else
566
567 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle)
568 {
569 if (anno.GetPointCount() == 4)
570 {
571 anno = ROI.CreateRectangle(App.viewer.GetCoordinate(),anno.X, anno.Y, e.X - anno.X, e.Y - anno.Y);
572 UpdateOverlay();
573 }
574 }
575 else
576 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse)
577 {
578 if (anno.GetPointCount() == 4)
579 {
580 anno = ROI.CreateEllipse(App.viewer.GetCoordinate(), anno.X, anno.Y, e.X - anno.X, e.Y - anno.Y);
581 UpdateOverlay();
582 }
583 }
584 else
585 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left && ImageView.down)
586 {
587 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
588 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
589 RectangleD r = Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle;
590 foreach (ROI an in App.viewer.AnnotationsRGB)
591 {
592 if (an.GetSelectBound(App.viewer.GetScale(), App.viewer.GetScale()).IntersectsWith(r))
593 {
594 an.selectedPoints.Clear();
595 ImageView.selectedAnnotations.Add(an);
596 an.Selected = true;
597 RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
598 for (int i = 0; i < sels.Length; i++)
599 {
600 if (sels[i].IntersectsWith(r))
601 {
602 an.selectedPoints.Add(i);
603 }
604 }
605 }
606 else
607 an.Selected = false;
608 }
609 UpdateOverlay();
610 }
611 else
612 if (currentTool.type == Tool.Type.rectSel && ImageView.up)
613 {
614 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
615 }
616 else
617 if (Win32.GetKeyState(Keys.Delete))
618 {
619 foreach (ROI an in ImageView.selectedAnnotations)
620 {
621 if (an != null)
622 {
623 if (an.selectedPoints.Count == 0)
624 {
625 ImageView.SelectedImage.Annotations.Remove(an);
626 }
627 else
628 {
629 if (an.type == ROI.Type.Polygon ||
630 an.type == ROI.Type.Polyline ||
631 an.type == ROI.Type.Freeform)
632 {
633 an.closed = false;
634 an.RemovePoints(an.selectedPoints.ToArray());
635
636 }
637 }
638 }
639 }
640 UpdateOverlay();
641 }
642
643 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
644 {
645 //First we draw the selection rectangle
646 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
647 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
648 UpdateOverlay();
649 }
650
651 if (buts == MouseButtons.Left && currentTool.type == Tool.Type.eraser)
652 {
653 Graphics g = Graphics.FromImage(ImageView.SelectedBuffer);
654 Pen pen = new Pen(Tools.EraseColor, (int)Tools.StrokeWidth,ImageView.SelectedBuffer.BitsPerPixel);
655 g.FillEllipse(new Rectangle((int)p.X, (int)p.Y, (int)width, (int)Tools.StrokeWidth), pen.color);
656 pen.Dispose();
657 App.viewer.UpdateImage();
658 }
659 if ((Tools.currentTool.type == Tools.Tool.Type.pan && (buts == MouseButtons.Middle || buts == MouseButtons.Left)))
660 {
661 if (ImageView.SelectedImage.isPyramidal)
662 {
663 if (ImageView.mouseDown.X - e.X != 0 || ImageView.mouseDown.Y - e.Y != 0)
664 {
665 App.viewer.PyramidalOriginTransformed = new PointD(App.viewer.PyramidalOriginTransformed.X + (ImageView.mouseDown.X - e.X), App.viewer.PyramidalOriginTransformed.Y + (ImageView.mouseDown.Y - e.Y));
666 }
667 }
668 else
669 {
670 // Screen-to-world conversion subtracts Origin. Moving the image
671 // toward the current pointer keeps the grabbed world point fixed.
672 App.viewer.Origin = new PointD(App.viewer.Origin.X + (e.X - ImageView.mouseDown.X), App.viewer.Origin.Y + (e.Y - ImageView.mouseDown.Y));
673 }
674 UpdateView();
675 }
676 }
Pen
System.Drawing.Pen Pen
Definition HistogramControl.cs:11
Keys
System.Windows.Forms.Keys Keys
Definition ImageView.cs:16
Graphics
System.Drawing.Graphics Graphics
Definition OMERO.cs:14
BioCore.Tools.selectBoxSize
static float selectBoxSize
Definition Tools.cs:213
BioCore.Tools.UpdateView
void UpdateView()
Definition Tools.cs:188

◆ ToolUp()

void BioCore.Tools.ToolUp ( PointD e,
MouseButtons buts )

The function ToolUp() is called when the mouse button is released

Parameters
PointDX,Y
MouseButtonsLeft, Right, Middle, XButton1, XButton2
Returns
a RectangleF.

Definition at line 382 of file Tools.cs.

383 {
384 PointD p;
385 p = ImageView.SelectedImage.ToImageSpace(e);
386 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null || anno == null)
387 return;
388 Scripting.UpdateState(Scripting.State.GetUp(e, buts));
389 if (currentTool.type == Tool.Type.point && buts == MouseButtons.Left)
390 {
391 ROI an = new ROI();
392 an.AddPoint(new PointD(e.X, e.Y));
393 an.type = ROI.Type.Point;
394 an.coord = App.viewer.GetCoordinate();
395 ImageView.SelectedImage.Annotations.Add(an);
396 }
397 else
398 if (currentTool.type == Tool.Type.line && anno.type == ROI.Type.Line && buts == MouseButtons.Left)
399 {
400 if (anno.GetPointCount() > 0)
401 {
402 anno.UpdatePoint(new PointD(e.X, e.Y), 1);
403 anno = new ROI();
404 }
405 }
406 else
407 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle && buts == MouseButtons.Left)
408 {
409 if (anno.GetPointCount() == 4)
410 {
411 anno = new ROI();
412 }
413 }
414 else
415 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse && buts == MouseButtons.Left)
416 {
417 if (anno.GetPointCount() == 4)
418 {
419 anno = new ROI();
420 }
421 }
422 else
423 if (currentTool.type == Tool.Type.freeform && anno.type == ROI.Type.Freeform && buts == MouseButtons.Left)
424 {
425 anno = new ROI();
426 }
427 else
428 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left)
429 {
430 ImageView.selectedAnnotations.Clear();
431 RectangleD r = GetTool(Tool.Type.rectSel).Rectangle;
432 foreach (ROI an in App.viewer.AnnotationsRGB)
433 {
434 if (an.GetSelectBound(App.viewer.GetScale(), App.viewer.GetScale()).ToRectangleF().IntersectsWith(r.ToRectangleF()))
435 {
436 an.selectedPoints.Clear();
437 ImageView.selectedAnnotations.Add(an);
438 an.Selected = true;
439 RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
440 for (int i = 0; i < sels.Length; i++)
441 {
442 if (sels[i].IntersectsWith(r))
443 {
444 an.selectedPoints.Add(i);
445 }
446 }
447 }
448 else
449 an.Selected = false;
450 }
451 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
452 }
453 else
454 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
455 {
456 PointD pf = new PointD(ImageView.mouseUp.X - ImageView.mouseDown.X, ImageView.mouseUp.Y - ImageView.mouseDown.Y);
457 ZCT coord = App.viewer.GetCoordinate();
458
459 Rectangle r = new Rectangle((int)ImageView.mouseDown.X, (int)ImageView.mouseDown.Y, (int)(ImageView.mouseUp.X - ImageView.mouseDown.X), (int)(ImageView.mouseUp.Y - ImageView.mouseDown.Y));
460 if (r.Width <= 2 || r.Height <= 2)
461 return;
462 Bitmap bf = ImageView.SelectedImage.Buffers[ImageView.SelectedImage.Coords[coord.Z, coord.C, coord.T]];
463 bf.Crop(r);
464 Statistics[] sts = Statistics.FromBytes(bf);
465 Statistics st = sts[0];
466 Threshold th;
467 if (magicSel.Numeric)
468 {
469 th = new Threshold((int)magicSel.Threshold);
470 }
471 else
472 if (magicSel.Index == 2)
473 th = new Threshold((int)(st.Min + st.Mean));
474 else
475 if (magicSel.Index == 1)
476 th = new Threshold((int)st.Median);
477 else
478 th = new Threshold((int)st.Min);
479 th.ApplyInPlace((Bitmap)bf.Image);
480 Invert inv = new Invert();
481 Bitmap det;
482 if (bf.BitsPerPixel > 8)
483 det = AForge.Imaging.Image.Convert16bppTo8bpp((Bitmap)bf.Image);
484 else
485 det = (Bitmap)bf.Image;
486 BlobCounter blobCounter = new BlobCounter();
487 blobCounter.ProcessImage(det);
488 Blob[] blobs = blobCounter.GetObjectsInformation();
489 // create convex hull searching algorithm
490 GrahamConvexHull hullFinder = new GrahamConvexHull();
491 // lock image to draw on it
492 // process each blob
493 foreach (Blob blob in blobs)
494 {
495 if (blob.Rectangle.Width < magicSel.Max && blob.Rectangle.Height < magicSel.Max)
496 continue;
497 List<IntPoint> leftPoints = new List<IntPoint>();
498 List<IntPoint> rightPoints = new List<IntPoint>();
499 List<IntPoint> edgePoints = new List<IntPoint>();
500 List<IntPoint> hull = new List<IntPoint>();
501 // get blob's edge points
502 blobCounter.GetBlobsLeftAndRightEdges(blob,
503 out leftPoints, out rightPoints);
504 edgePoints.AddRange(leftPoints);
505 edgePoints.AddRange(rightPoints);
506 // blob's convex hull
507 hull = hullFinder.FindHull(edgePoints);
508 PointD[] pfs = new PointD[hull.Count];
509 for (int i = 0; i < hull.Count; i++)
510 {
511 pfs[i] = new PointD(r.X + hull[i].X, r.Y + hull[i].Y);
512 }
513 ROI an = ROI.CreateFreeform(coord, pfs);
514 ImageView.SelectedImage.Annotations.Add(an);
515 }
516 }
517 else
518 if (Tools.currentTool.type == Tools.Tool.Type.bucket && buts == MouseButtons.Left)
519 {
520 ZCT coord = App.viewer.GetCoordinate();
521 floodFiller.FillColor = DrawColor;
522 floodFiller.Tolerance = currentTool.tolerance;
523 floodFiller.Bitmap = ImageView.SelectedImage.Buffers[ImageView.SelectedImage.Coords[coord.C, coord.Z, coord.T]];
524 floodFiller.FloodFill(new AForge.Point((int)p.X, (int)p.Y));
525 App.viewer.UpdateImages();
526 }
527 else
528 if (Tools.currentTool.type == Tools.Tool.Type.dropper && buts == MouseButtons.Left)
529 {
530 DrawColor = ImageView.SelectedBuffer.GetPixel((int)p.X,(int)p.Y);
531 UpdateGUI();
532 }
533 UpdateOverlay();
534 }
BioCore.Tools.Tool.Rectangle
RectangleD Rectangle
Definition Tools.cs:82
BioCore.Tools.Tool.tolerance
ColorS tolerance
Definition Tools.cs:92
BioCore.Tools.DrawColor
static ColorS DrawColor
Definition Tools.cs:126

◆ UpdateOverlay()

void BioCore.Tools.UpdateOverlay ( )

Definition at line 184 of file Tools.cs.

185 {
186 App.viewer.UpdateOverlay();
187 }

◆ UpdateSelected()

void BioCore.Tools.UpdateSelected ( )

It loops through all the controls in the form and if the control has a tag of "tool" it sets the background color to white

Definition at line 194 of file Tools.cs.

195 {
196 foreach (Control item in this.Controls)
197 {
198 if(item.Tag != null)
199 if(item.Tag.ToString() == "tool")
200 item.BackColor = System.Drawing.Color.White;
201 }
202 }

◆ UpdateView()

void BioCore.Tools.UpdateView ( )

Definition at line 188 of file Tools.cs.

189 {
190 App.viewer.UpdateView();
191 }

Member Data Documentation

◆ applyToStack

bool BioCore.Tools.applyToStack = false
static

Definition at line 21 of file Tools.cs.

◆ bEnabled

bool BioCore.Tools.bEnabled = true
static

Definition at line 25 of file Tools.cs.

◆ colorTool

ColorTool BioCore.Tools.colorTool
static

Definition at line 22 of file Tools.cs.

◆ currentTool

Tool BioCore.Tools.currentTool
static

Definition at line 124 of file Tools.cs.

◆ font

Font BioCore.Tools.font

Definition at line 162 of file Tools.cs.

◆ gEnabled

bool BioCore.Tools.gEnabled = true
static

Definition at line 24 of file Tools.cs.

◆ rEnabled

bool BioCore.Tools.rEnabled = true
static

Definition at line 23 of file Tools.cs.

◆ selectBoxSize

float BioCore.Tools.selectBoxSize = ROI.selectBoxSize
static

Definition at line 213 of file Tools.cs.

◆ selectionRect

RectangleD BioCore.Tools.selectionRect
static

Definition at line 161 of file Tools.cs.

◆ selectionRectangle

Rectangle BioCore.Tools.selectionRectangle
static

Definition at line 30 of file Tools.cs.

◆ tools

Hashtable BioCore.Tools.tools = new Hashtable()
static

Definition at line 31 of file Tools.cs.

Property Documentation

◆ DrawColor

ColorS BioCore.Tools.DrawColor
staticgetset

Definition at line 125 of file Tools.cs.

126 {
127 get
128 {
129 return drawColor;
130 }
131 set
132 {
133 drawColor = value;
134 }
135 }

◆ EraseColor

ColorS BioCore.Tools.EraseColor
staticgetset

Definition at line 136 of file Tools.cs.

137 {
138 get
139 {
140 return eraseColor;
141 }
142 set
143 {
144 eraseColor = value;
145 }
146 }

◆ StrokeWidth

int BioCore.Tools.StrokeWidth
staticgetset

Definition at line 148 of file Tools.cs.

149 {
150 get
151 {
152 return width;
153 }
154 set
155 {
156 width = value;
157 App.tools.UpdateGUI();
158 }
159 }
The documentation for this class was generated from the following files: