//=============================================================================
public void Draw()
{
if (m_DC == null)
{
return;
}
DrawingSheet currSheet = m_DC.Sheet;
if (currSheet == null)
{
return;
}
//
// if there is no one line to draw you steel need to call RenderOpen() to remove all old lines
this.Opacity = 0.35;
// draw online snapped line
using (DrawingContext thisDC = this.RenderOpen())
{
if (!m_DC.DisplaySelectionRectangle)
{
return;
}
Point pnt01 = m_DC.GetLocalPoint(currSheet, m_DC.SelectionFirstGlobalPnt);
Point pnt02 = m_DC.GetLocalPoint(currSheet, m_DC.SelectionSecondGlobalPnt);
//
thisDC.DrawRectangle(m_DC.SelectionRectangleFillBrush, new Pen(m_DC.SelectionRectangleBorderBrush, 1), new Rect(pnt01, pnt02));
}
}
/// <summary>
/// 创建基本视图
/// </summary>
/// <returns></returns>
public static BaseView CreateBaseView(DrawingSheet ds, Snap.NX.Body body)
{
//UFUN创建基本视图函数
var workPart = NXOpen.Session.GetSession().Parts.Work;
var theUFSession = NXOpen.UF.UFSession.GetUFSession();
var modelView = workPart.ModelingViews.FindObject("FRONT");
var draw_view_tag = CreateView(ds, body, modelView.Tag, new Snap.Position(ds.Length / 2, ds.Height / 2));
Tag top = Tag.Null;
var topFace = body.Faces.FirstOrDefault(u => u.GetAttributeInfo().Where(m => m.Title == "ATTR_NAME_MARK" && u.GetStringAttribute("ATTR_NAME_MARK") == "BASE_BOT").Count() > 0);
top = topFace.NXOpenTag;
var box = body.Box;
var min = new Snap.Position((box.MinX + box.MaxX) / 2, (box.MinY + box.MaxY) / 2, box.MinZ);
var plane = new Snap.Geom.Surface.Plane(min, topFace.GetFaceDirection());
var bottomFace =
body.Faces.OrderBy(u =>
Snap.Compute.Distance(min, u)
).FirstOrDefault();
Tag bottom = Tag.Null;
//theUFSession.Obj.CycleByName("BOTTOMEDGE", ref bottom);
bottom = bottomFace.NXOpenTag;
CreateVerticalDim(draw_view_tag, top, bottom, new Snap.Position((ds.Length / 2) + GetBorderSize(draw_view_tag).X / 2, ds.Height / 2, 0));
return(null);
}
public static List <string> GetIndirectInputsList(DrawingSheet sheet)
{
List <string> list;
if (sheet is ModelSheet model)
{
list = model.Variables.IndirectInputs.ConvertAll(var => var.Name);
foreach (Nested nested in model.Sketch.Nesteds)
{
if (nested.PointedSheet == null)
{
continue;
}
nested.PointedSheet.Variables.Outputs.ForEach(var => list.Add(string.Format("{0}.{1}", nested.Name, var.Name)));
}
}
else
{
list = sheet.OwnerBook.Variables.IndirectInputs.ConvertAll(var => var.Name);
foreach (GlobalSheet gsheet in sheet.OwnerBook.GlobalSheets)
{
foreach (Nested nested in gsheet.Sketch.Nesteds)
{
if (nested.PointedSheet == null)
{
continue;
}
nested.PointedSheet.Variables.Outputs.ForEach(var => list.Add(string.Format("{0}.{1}", nested.Name, var.Name)));
}
}
}
return(list);
}
public static Dictionary <string, int> GetOutputsDictionary(DrawingSheet sheet)
{
Dictionary <string, int> dictionary;
if (sheet is ModelSheet model)
{
dictionary = model.Variables.InternalOutputs.ToDictionary(var => var.Name, var => var.GetImageIndex());
foreach (Nested nested in model.Sketch.Nesteds)
{
if (nested.PointedSheet == null)
{
continue;
}
nested.PointedSheet.Variables.Inputs.ForEach(var => dictionary.Add(string.Format("{0}.{1}", nested.Name, var.Name), var.GetImageIndex()));
}
}
else
{
dictionary = sheet.OwnerBook.Variables.InternalOutputs.ToDictionary(var => var.Name, var => var.GetImageIndex());
foreach (GlobalSheet gsheet in sheet.OwnerBook.GlobalSheets)
{
foreach (Nested nested in gsheet.Sketch.Nesteds)
{
nested.PointedSheet?.Variables.Inputs.ForEach(var => dictionary.Add(string.Format("{0}.{1}", nested.Name, var.Name), var.GetImageIndex()));
}
}
}
return(dictionary);
}
private static void On_Sheet_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
DrawingSheet oldSheet = e.OldValue as DrawingSheet;
if (oldSheet != null)
{
oldSheet.PropertyChanged -= SheetPropertyChanged;
}
DrawingSheet newSheet = e.NewValue as DrawingSheet;
if (newSheet != null)
{
newSheet.PropertyChanged += SheetPropertyChanged;
}
RackAppViewport3D rackViewport = d as RackAppViewport3D;
if (rackViewport != null)
{
// Zoom to fit all content when user changes sheet.
rackViewport.m_bZoomExtents = true;
rackViewport.UpdateGeometry();
}
}
public EditSheetNotesDailogViewModel(DrawingSheet sheet)
{
if (sheet != null)
{
Notes = sheet.Notes;
}
}
//
// Shutter is placed on the borders only.
// If it is horizontal border then shutter has fixed height SHUTTER_DEPTH,
// if it is vertical - fixed width SHUTTER_DEPTH.
//
// No one block cant overlap shutter.
public Shutter(DrawingSheet ds)
: base(ds)
{
m_FillColor = Colors.Pink;
//
MinLength_X = SHUTTER_DEPTH;
MinLength_Y = SHUTTER_DEPTH;
//
MaxLength_Y = double.PositiveInfinity;
MaxLength_X = double.PositiveInfinity;
MaxLength_Z = 100000;
//
IsHorizontal = true;
Length_Y = SHUTTER_DEPTH;
//
StepLength_X = 50;
StepLength_Y = 50;
//
Name = "Shutter";
}
//=============================================================================
public void AfterGripPointMove(int iGripIndex)
{
// Ignore center grip point because it doesnt change size and top left point position.
if (BaseRectangleGeometry.GRIP_CENTER == iGripIndex)
{
m_IsCenterGripPointMoving = false;
m_OldTopLeftPoint = this.TopLeft_GlobalPoint;
}
// Read comment inside BeforeGripPointMove() function.
// Apply changes to the bound sheet.
DrawingSheet boundSheet = this.BoundSheet;
if (this.IsInit && boundSheet != null)
{
Vector boundSheetTopLeftPointOffset = this.TopLeft_GlobalPoint - m_OldTopLeftPoint;
if (!_TryToChangeBoundSheetSize(boundSheetTopLeftPointOffset, m_Length_X, m_Length_Y))
{
m_Length_X = boundSheet.Length;
m_Length_Y = boundSheet.Width;
}
}
m_bDontChangeBoundSheetSize = false;
if (this.IsInit)
{
m_OldSize.Width = 0.0;
m_OldSize.Height = 0.0;
m_OldTopLeftPoint = new Point(0.0, 0.0);
}
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
Nested nested = context.Instance as Nested;
DrawingSheet sheet = nested.OwnerDraw.OwnerSheet;
return(new StandardValuesCollection(sheet.OwnerBook.Models.FindAll(model => model != sheet).ConvertAll(model => model.Name)));
}
//=============================================================================
private async void SheetTextBlock_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (e.ClickCount == 2)
{
DrawingSheet _sheet = null;
TextBlock tb = sender as TextBlock;
if (tb != null)
{
_sheet = tb.DataContext as DrawingSheet;
}
if (_sheet != null && _sheet.Document != null)
{
SheetNameDialog_ViewModel vm = new SheetNameDialog_ViewModel(_sheet);
vm.Name = _sheet.Name;
SheetName_Dialog _SheetNameDialog = new SheetName_Dialog(vm);
// true - OK
// false - CANCEL
var result = await DialogHost.Show(_SheetNameDialog);
if (result is bool && (bool)result)
{
_sheet.Name = vm.Name;
_sheet.MarkStateChanged();
}
}
e.Handled = true;
}
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
DrawableObject obj = context.Instance as DrawableObject;
DrawingSheet sheet = obj.OwnerDraw.OwnerSheet;
return(new StandardValuesCollection(VariableCollection.GetIndirectOutputsList(sheet)));
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
Relation relation = context.Instance as Relation;
DrawingSheet sheet = relation.OwnerDraw.OwnerSheet;
return(new StandardValuesCollection(VariableCollection.GetIndirectInputsList(sheet)));
}
public AisleSpace(DrawingSheet ds)
: base(ds)
{
//
m_FillColor = Colors.Khaki;
//
MinLength_X = 100;
MinLength_Y = 100;
//
MaxLength_Y = double.PositiveInfinity;
MaxLength_X = double.PositiveInfinity;
//
StepLength_X = 5;
StepLength_Y = 5;
// calculate LengthX and LengthY based on the MHE travel width options
Length_X = Utils.CheckWholeNumber(Length_X, MinLength_X, MaxLength_X);
Length_Y = Utils.CheckWholeNumber(Length_Y, MinLength_Y, MaxLength_Y);
//
Name = "Aisle space";
OnSizeChanged();
}
public Column(DrawingSheet ds)
: base(ds)
{
Text = "C";
//
StepLength_X = 25;
StepLength_Y = 25;
MinLength_Y = 300;
MinLength_X = 300;
//
MaxLength_X = 1000;
MaxLength_Y = 1000;
//
Length_X = 1000;
Length_Y = 1000;
//
m_FillColor = Colors.LightSkyBlue;
ColumnPattern_ID = -1;
CanContinuePattern = true;
}
/// <summary>
/// Создает листы с картами инструментов
/// Заполняет таблицу описанием операций
/// </summary>
/// <param name="operationDescriptions"></param>
/// <param name="drawingsFormats"></param>
private void AddDescriptionsToSheets(List <string[]> operationDescriptions, NxDrawingsFromat[] drawingsFormats)
{
var layerManager = _part.Layers;
if (layerManager.WorkLayer != 256)
{
layerManager.SetState(256, State.WorkLayer);
}
foreach (var descr in operationDescriptions)
{
if (tabnote == Tag.Null)
{
_currentSheet = CreateSheet(_part, drawingsFormats.FirstOrDefault(df => df.DrawingType == 1 && df.IsFirstSheet));
if (_currentSheet != null)
{
SetSheetNotes(_currentSheet);
}
if (_firstSheet == null)
{
_firstSheet = _currentSheet;
}
tabnote = GetTableSectionTag("КАРТА_ИНСТРУМЕНТОВ", _currentSheet);
ufs.Tabnot.AskNmRows(tabnote, out rowNums);
}
if (row >= rowNums)
{
_currentSheet = CreateSheet(_part, drawingsFormats.FirstOrDefault(df => df.DrawingType == 1 && !df.IsFirstSheet));
if (_currentSheet != null)
{
SetSheetNotes(_currentSheet);
}
tabnote = GetTableSectionTag("КАРТА_ИНСТРУМЕНТОВ", _currentSheet);
ufs.Tabnot.AskNmRows(tabnote, out rowNums);
row = 0;
}
int columnNums;
ufs.Tabnot.AskNmColumns(tabnote, out columnNums);
Tag rowTag;
ufs.Tabnot.AskNthRow(tabnote, row++, out rowTag);
var col = 0;
foreach (var s in descr)
{
Tag colTag, cell;
ufs.Tabnot.AskNthColumn(tabnote, col++, out colTag);
ufs.Tabnot.AskCellAtRowCol(rowTag, colTag, out cell);
ufs.Tabnot.SetCellText(cell, s);
if (col > columnNums)
{
break;
}
}
}
layerManager.SetState(1, State.WorkLayer);
layerManager.SetState(256, State.Visible);
}
public ColumnPattern(DrawingSheet ds)
{
m_Sheet = ds;
ID = -1;
GlobalOffset_X = 5000;
GlobalOffset_Y = 5000;
}
public DrawAction(ActionTypes actionType, DrawingSheet sheet, List <DrawableObject> objects,
List <DrawableObject> selection, int focusIndex) : base(actionType)
{
Sheet = sheet;
DrawRef = new List <DrawableObject>(objects);
Selection = new List <DrawableObject>(selection);
FocusSelectionIndex = focusIndex;
}
//=============================================================================
public void Draw(bool bShow)
{
if (m_DC == null)
{
return;
}
DrawingSheet currSheet = m_DC.Sheet;
if (currSheet == null)
{
return;
}
// if there is no one line to draw you steel need to call RenderOpen() to remove all old lines
//if (m_owner.m_VerticalLines.Count == 0 && m_owner.m_HorizontalLines.Count == 0)
// return;
// draw online snapped line
using (DrawingContext thisDC = this.RenderOpen())
{
if (!bShow)
{
return;
}
//
Pen linesPen = new Pen(m_DC.SnappingLinesBrush, 1.0);
// draw vert
if (m_DC.VertLine_X > 0)
{
//
Point startPnt = new Point(m_DC.VertLine_X, 0);
startPnt = m_DC.GetLocalPoint(currSheet, startPnt);
Point endPnt = new Point(m_DC.VertLine_X, currSheet.Width);
endPnt = m_DC.GetLocalPoint(currSheet, endPnt);
//
thisDC.DrawLine(linesPen, startPnt, endPnt);
}
// draw horiz
if (m_DC.HorizLine_Y > 0)
{
//
Point startPnt = new Point(0, m_DC.HorizLine_Y);
startPnt = m_DC.GetLocalPoint(currSheet, startPnt);
Point endPnt = new Point(currSheet.Length, m_DC.HorizLine_Y);
endPnt = m_DC.GetLocalPoint(currSheet, endPnt);
//
thisDC.DrawLine(linesPen, startPnt, endPnt);
}
}
}
//=============================================================================
//
// screenPoint - point relative DrawingControl's top left corner
//
// Returns "global" point in Length_Y and Length_Z values
// It allow to show drawing always correct, DrawingContol's
// real width and height doesnt matter. Because all geometry
// save only global points. If you change application's window size
// then drawing will be shown correct also.
//
// It is NECESSARY to save all geometry in global points.
//
static public Point sGetGlobalPoint(Point screenPoint, DrawingSheet sheet)
{
if (sheet == null)
{
return(new Point());
}
return(sGetGlobalPoint(screenPoint, sheet.UnitsPerCameraPixel, sheet.GetCameraOffset()));
}
//=============================================================================
protected override void OnRender(DrawingContext drawingContext)
{
if (drawingContext == null)
{
return;
}
DrawingSheet sheet = this.Sheet;
if (sheet == null)
{
return;
}
// STEP 1.
// Draw sheet content with opacity.
drawingContext.PushOpacity(0.2);
//
int LengthInPixels = Utils.GetWholeNumber(this.ActualWidth); //Utils.GetWholeNumber(cs.GetWidthInPixels(DrawingGlobalSize.Width, Length_X));
int HeightInPixels = Utils.GetWholeNumber(this.ActualHeight); //Utils.GetWholeNumber(cs.GetHeightInPixels(DrawingGlobalSize.Height, Length_Y));
//
ImageCoordinateSystem ics = new ImageCoordinateSystem(LengthInPixels, HeightInPixels, new Vector(0.0, 0.0), new Size(sheet.Length, sheet.Width), 0.0);
DefaultGeomDisplaySettings geomDisplaySettings = new DefaultGeomDisplaySettings();
geomDisplaySettings.DisplayText = false;
//
if (sheet.Rectangles != null)
{
foreach (BaseRectangleGeometry geom in sheet.Rectangles)
{
if (geom == null)
{
continue;
}
// Dont display SheetElevationGeometry, because it has fixed size in pixels
if (geom is SheetElevationGeometry)
{
continue;
}
geom.Draw(drawingContext, ics, geomDisplaySettings);
}
}
// Pop opacity
drawingContext.Pop();
// STEP 2.
// Draw gray sheet border.
Size drawingSize = new Size(sheet.Length, sheet.Width);
Point pt_01 = ics.GetLocalPoint(new Point(0.0, 0.0), sheet.UnitsPerCameraPixel, sheet.GetCameraOffset());
Point pt_02 = ics.GetLocalPoint(new Point(sheet.Length, sheet.Width), sheet.UnitsPerCameraPixel, sheet.GetCameraOffset());
drawingContext.DrawRectangle(null, new Pen(Brushes.Gray, 1.0), new Rect(pt_01, pt_02));
}
public static Variable GetIndirectOutput(DrawingSheet sheet, string name)
{
if (name.Contains("."))
{
if (sheet is ModelSheet model)
{
foreach (Nested nested in model.Sketch.Nesteds)
{
if (nested.PointedSheet == null)
{
continue;
}
foreach (Variable var in nested.PointedSheet.Variables.Inputs)
{
if (string.Format("{0}.{1}", nested.Name, var.Name) == name)
{
return(var);
}
}
}
}
else
{
foreach (GlobalSheet gsheet in sheet.OwnerBook.GlobalSheets)
{
foreach (Nested nested in gsheet.Sketch.Nesteds)
{
if (nested.PointedSheet == null)
{
continue;
}
foreach (Variable var in nested.PointedSheet.Variables.Inputs)
{
if (string.Format("{0}.{1}", nested.Name, var.Name) == name)
{
return(var);
}
}
}
}
}
}
else
{
if (sheet.Variables.IndirectOutputs.Exists(obj => obj.Name == name))
{
return(sheet.Variables.All.FindAll(var => var is IIndirectOutput).FirstOrDefault(obj => obj.Name == name));
}
else
{
return(null);
}
}
return(null);
}
//=============================================================================
public void Draw(bool bShow)
{
if (m_DC == null)
{
return;
}
DrawingSheet currSheet = m_DC.Sheet;
if (currSheet == null)
{
return;
}
//
// if there is no one line to draw you steel need to call RenderOpen() to remove all old lines
this.Opacity = 0.3;
// draw online snapped line
using (DrawingContext thisDC = this.RenderOpen())
{
if (!bShow)
{
return;
}
// draw new rectangle
if ((m_DC.PreviewGlobalLength > 0 && m_DC.PreviewGlobalLength < currSheet.Length) ||
(m_DC.PreviewGlobalWidth > 0 && m_DC.PreviewGlobalWidth < currSheet.Width))
{
//
Point startPnt = new Point(0, 0);
startPnt = m_DC.GetLocalPoint(currSheet, startPnt);
//
double length = currSheet.Length;
if (m_DC.PreviewGlobalLength > 0 && m_DC.PreviewGlobalLength < currSheet.Length)
{
length = m_DC.PreviewGlobalLength;
}
//
double width = currSheet.Width;
if (m_DC.PreviewGlobalWidth > 0 && m_DC.PreviewGlobalWidth < currSheet.Width)
{
width = m_DC.PreviewGlobalWidth;
}
//
Point endPnt = new Point(length, width);
endPnt = m_DC.GetLocalPoint(currSheet, endPnt);
//
thisDC.DrawRectangle(m_DC.NewSizePreviewFillBrush, new Pen(m_DC.NewSizePreviewBorderBrush, 2), new Rect(startPnt, endPnt));
}
}
}
//=============================================================================
protected override void OnRender(DrawingContext drawingContext)
{
if (drawingContext == null)
{
return;
}
DrawingSheet sheet = this.Sheet;
if (sheet == null)
{
return;
}
if (sheet.IsSheetFullyDisplayed)
{
return;
}
if (DrawingDocument._sDrawing == null)
{
return;
}
// Draw sheet border and background.
Point topLeftPnt = new Point(0.0, 0.0);
Point botRightPnt = new Point(this.ActualWidth, this.ActualHeight);
drawingContext.DrawRectangle(this.BackgroundBrush, new Pen(this.BorderBrush, 1.0), new Rect(topLeftPnt, botRightPnt));
Vector cameraOffset = sheet.GetCameraOffset();
double cameraWidthInUnits = DrawingDocument._sDrawing.ActualWidth * sheet.UnitsPerCameraPixel;
double cameraHeightInUnits = DrawingDocument._sDrawing.ActualHeight * sheet.UnitsPerCameraPixel;
// Draw camera area
Point cameraAreaTopLeftPnt = new Point(0.0, 0.0);
cameraAreaTopLeftPnt.X += (cameraOffset.X / sheet.Length) * this.ActualWidth;
if (Utils.FGT(cameraWidthInUnits, sheet.Length))
{
cameraAreaTopLeftPnt.X = this.ActualWidth / 2 - ((cameraWidthInUnits / 2) / sheet.Length) * this.ActualWidth;
}
cameraAreaTopLeftPnt.Y += (cameraOffset.Y / sheet.Width) * this.ActualHeight;
if (Utils.FGT(cameraHeightInUnits, sheet.Width))
{
cameraAreaTopLeftPnt.Y = this.ActualHeight - ((cameraHeightInUnits / 2) / sheet.Width) * this.ActualHeight;
}
Point cameraAreaBotRightPnt = cameraAreaTopLeftPnt;
cameraAreaBotRightPnt.X += (cameraWidthInUnits / sheet.Length) * this.ActualWidth;
cameraAreaBotRightPnt.Y += (cameraHeightInUnits / sheet.Width) * this.ActualHeight;
drawingContext.DrawRectangle(this.CameraAreaBrush, null, new Rect(cameraAreaTopLeftPnt, cameraAreaBotRightPnt));
}
public List <Link> ContainedTransitionLinks()
{
var list = new List <Link>();
DrawingSheet sheet = OwnerDraw.OwnerSheet.OwnerBook.Sheets.FirstOrDefault(sh => sh.Name == PointingTo);
if (sheet == null)
{
return(list);
}
return(sheet.Sketch.Objects.FindAll(obj => obj is End || obj is Abort).ConvertAll(link => (Link)link));
}
//=============================================================================
private void WallButton_Click(object sender, RoutedEventArgs e)
{
//
DrawingSheet _currSheet = _Get_CurrentSheet();
if (_currSheet == null)
{
return;
}
_currSheet.CreateWall();
}
//=============================================================================
private DrawingSheet _Get_CurrentSheet()
{
DrawingSheet _currSheet = null;
//
if (m_VM != null && m_VM.CurrentDocument != null)
{
_currSheet = m_VM.CurrentDocument.CurrentSheet;
}
return(_currSheet);
}
//
private void On_Sheet_Changed(DrawingSheet oldSheet, DrawingSheet newSheet)
{
if (oldSheet != null)
{
oldSheet.PropertyChanged -= SheetPropertyChanged;
}
if (newSheet != null)
{
newSheet.PropertyChanged += SheetPropertyChanged;
}
}
//=============================================================================
private void CreateSheetButton_Click(object sender, RoutedEventArgs e)
{
Button btn = sender as Button;
if (btn == null)
{
return;
}
MainWindow_ViewModel mainVM = btn.DataContext as MainWindow_ViewModel;
if (mainVM == null)
{
return;
}
DrawingDocument curDoc = mainVM.CurrentDocument;
if (curDoc == null)
{
return;
}
WarehouseSheet curSheet = curDoc.CurrentSheet as WarehouseSheet;
if (curSheet == null || curSheet.SingleSelectedGeometry == null)
{
return;
}
SheetGeometry sheetGeometry = curSheet.SingleSelectedGeometry as SheetGeometry;
if (sheetGeometry == null)
{
return;
}
if (sheetGeometry.BoundSheet != null)
{
return;
}
DrawingSheet newSheet = new DrawingSheet(curDoc);
if (newSheet != null)
{
newSheet.Set_Length((UInt32)Utils.GetWholeNumber(sheetGeometry.Length_X), false, false);
newSheet.Set_Width((UInt32)Utils.GetWholeNumber(sheetGeometry.Length_Y), false, false);
curDoc.AddSheet(newSheet, false);
sheetGeometry.BoundSheet = newSheet;
curDoc.MarkStateChanged();
}
}
//=============================================================================
public override object GetPropertyValue(string strPropSysName)
{
if (BaseRectangleGeometry.PROP_NAME == strPropSysName)
{
DrawingSheet boundSheet = this.BoundSheet;
if (boundSheet != null)
{
return(boundSheet.Name);
}
}
return(base.GetPropertyValue(strPropSysName));
}
public SheetElevationGeometry(DrawingSheet ds)
: base(ds)
{
Name = "Sheet Elevation";
Text = "SE";
this.Length_X = 1.0;
this.Length_Y = 1.0;
this.Length_Z = 1;
this.ShowRotationGrips = false;
this.IsInit = true;
}