//---------------------------------------------------------
bool CWKSP_Shapes::_Edit_Shape_Del(void)
{
if( DLG_Message_Confirm(_TL("Delete selected shape(s)."), _TL("Edit Shapes")) )
{
if( Get_Shapes()->Get_Selection_Count() > 0 )
{
if( m_Edit_pShape )
{
_Edit_Shape_Stop(false);
Get_Shapes()->Del_Shape(Get_Shapes()->Get_Selection(m_Edit_Index));
}
else
{
Get_Shapes()->Del_Selection();
}
Edit_Set_Index(0);
Update_Views();
return( true );
}
return( _Edit_Shape_Stop(false) );
}
return( false );
}
bool CWKSP_Shapes::_Edit_Shape_Stop(bool bSave)
{
if( m_Edit_pShape != NULL )
{
if( bSave )
{
CSG_Shape *pShape = Get_Shapes()->Get_Selection(m_Edit_Index);
if( pShape == NULL )
{
Get_Shapes()->Select(pShape = Get_Shapes()->Add_Shape());
m_Edit_Index = 0;
}
if( pShape != NULL )
{
pShape->Assign(m_Edit_pShape, false);
}
}
m_Edit_Shapes.Del_Shapes();
m_Edit_pShape = NULL;
m_Edit_Mode = EDIT_SHAPE_MODE_Normal;
Edit_Set_Index(m_Edit_Index);
Update_Views();
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CWKSP_Shapes::_Edit_Point_Del(void)
{
if( m_Edit_pShape && m_Edit_iPart >= 0 && m_Edit_iPoint >= 0 )
{
if( m_Edit_pShape->Get_Point_Count(m_Edit_iPart) > 1 )
{
m_Edit_pShape->Del_Point(m_Edit_iPoint, m_Edit_iPart);
if( m_Edit_iPoint >= m_Edit_pShape->Get_Point_Count(m_Edit_iPart) )
{
m_Edit_iPoint = m_Edit_pShape->Get_Point_Count(m_Edit_iPart) - 1;
}
if( m_Edit_pShape->Get_Point_Count(m_Edit_iPart) <= 1 )
{
if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Line || Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon )
{
m_Edit_iPoint = -1;
}
}
Update_Views(false);
return( true );
}
else
{
return( _Edit_Part_Del() );
}
}
return( false );
}
//---------------------------------------------------------
bool CWKSP_Shapes::Edit_Set_Index(int Index)
{
m_Edit_Attributes.Del_Records();
if( Index > Get_Shapes()->Get_Selection_Count() )
{
Index = Get_Shapes()->Get_Selection_Count();
}
CSG_Table_Record *pSelection = Get_Shapes()->Get_Selection(Index);
if( pSelection )
{
m_Edit_Index = Index;
for(int i=0; i<Get_Shapes()->Get_Field_Count(); i++)
{
CSG_Table_Record *pRecord = m_Edit_Attributes.Add_Record();
pRecord->Set_Value(0, pSelection->Get_Table()->Get_Field_Name(i));
pRecord->Set_Value(1, pSelection->asString(i));
}
}
else
{
m_Edit_Index = 0;
}
return( true );
}
//---------------------------------------------------------
bool CQuadTree_Structure::On_Execute(void)
{
CSG_PRQuadTree QT(Parameters("SHAPES")->asShapes(), Parameters("ATTRIBUTE")->asInt());
Get_Shapes(Parameters("LINES") ->asShapes(), (CSG_PRQuadTree_Item *)&QT.Get_Root(), SHAPE_TYPE_Line);
Get_Shapes(Parameters("POLYGONS") ->asShapes(), (CSG_PRQuadTree_Item *)&QT.Get_Root(), SHAPE_TYPE_Polygon);
return( true );
}
//---------------------------------------------------------
void CWKSP_Shapes_Point::On_Parameters_Changed(void)
{
CWKSP_Shapes::On_Parameters_Changed();
//-----------------------------------------------------
m_Symbol_Type = m_Parameters("DISPLAY_SYMBOL_TYPE")->asInt();
if( !SG_File_Exists (m_Parameters("DISPLAY_SYMBOL_IMAGE")->asString())
|| !m_Symbol.LoadFile(m_Parameters("DISPLAY_SYMBOL_IMAGE")->asString()) )
{
m_Symbol = IMG_Get_Image(ID_IMG_DEFAULT);
}
//-----------------------------------------------------
m_Size_Type = m_Parameters("SIZE_TYPE") ->asInt();
m_Size_Scale = m_Parameters("SIZE_SCALE")->asInt();
if( (m_iSize = m_Parameters("SIZE_ATTRIB")->asInt()) >= Get_Shapes()->Get_Field_Count()
|| (m_dSize = Get_Shapes()->Get_Maximum(m_iSize) - (m_Size_Min = Get_Shapes()->Get_Minimum(m_iSize))) <= 0.0 )
{
m_iSize = -1;
m_Size = m_Parameters("SIZE_DEFAULT")->asDouble();
}
else
{
m_Size = m_Parameters("SIZE_RANGE")->asRange()->Get_LoVal();
m_dSize = (m_Parameters("SIZE_RANGE")->asRange()->Get_HiVal() - m_Size) / m_dSize;
}
//-----------------------------------------------------
m_Label_Angle = m_Parameters("LABEL_ANGLE")->asDouble();
if( (m_iLabel_Angle = m_Parameters("LABEL_ANGLE_ATTRIB")->asInt()) >= Get_Shapes()->Get_Field_Count() )
{
m_iLabel_Angle = -1;
}
switch( m_Parameters("LABEL_ALIGN_X")->asInt() )
{
case 0: m_Label_Align = TEXTALIGN_LEFT; break;
case 1: m_Label_Align = TEXTALIGN_XCENTER; break;
case 2: m_Label_Align = TEXTALIGN_RIGHT; break;
}
switch( m_Parameters("LABEL_ALIGN_Y")->asInt() )
{
case 0: m_Label_Align |= TEXTALIGN_TOP; break;
case 1: m_Label_Align |= TEXTALIGN_YCENTER; break;
case 2: m_Label_Align |= TEXTALIGN_BOTTOM; break;
}
//-----------------------------------------------------
m_bOutline = m_Parameters("OUTLINE")->asBool();
m_Pen = wxPen(!m_bOutline ? m_Def_Color : Get_Color_asWX(m_Parameters("OUTLINE_COLOR")->asColor()), m_Parameters("OUTLINE_SIZE")->asInt(), wxSOLID);
m_Brush = wxBrush(m_Def_Color, BrushList_Get_Style(m_Parameters("DISPLAY_BRUSH")->asInt()));
}
//---------------------------------------------------------
int CWKSP_Shapes_Point::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter, int Flags)
{
//-----------------------------------------------------
if( Flags & PARAMETER_CHECK_VALUES )
{
if( !SG_STR_CMP(pParameter->Get_Identifier(), wxT("COLORS_FONT")) )
{
int zField = pParameters->Get_Parameter("METRIC_ATTRIB")->asInt();
pParameters->Get_Parameter("METRIC_ZRANGE")->asRange()->Set_Range(
Get_Shapes()->Get_Minimum(zField),
Get_Shapes()->Get_Maximum(zField)
);
}
}
//-----------------------------------------------------
if( Flags & PARAMETER_CHECK_ENABLE )
{
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("DISPLAY_SYMBOL_TYPE")) )
{
pParameters->Get_Parameter("DISPLAY_SYMBOL_IMAGE")->Set_Enabled(pParameter->asInt() == pParameter->asChoice()->Get_Count() - 1);
}
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("LABEL_ATTRIB")) )
{
bool Value = pParameter->asInt() < Get_Shapes()->Get_Field_Count();
pParameters->Get_Parameter("LABEL_ANGLE_ATTRIB")->Set_Enabled(Value);
pParameters->Get_Parameter("LABEL_ANGLE" )->Set_Enabled(Value);
pParameters->Get_Parameter("LABEL_ALIGN_X" )->Set_Enabled(Value);
pParameters->Get_Parameter("LABEL_ALIGN_Y" )->Set_Enabled(Value);
}
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("SIZE_ATTRIB")) )
{
bool Value = pParameter->asInt() < Get_Shapes()->Get_Field_Count();
pParameters->Get_Parameter("SIZE_SCALE" )->Set_Enabled(Value == true);
pParameters->Get_Parameter("SIZE_RANGE" )->Set_Enabled(Value == true);
pParameters->Get_Parameter("SIZE_DEFAULT")->Set_Enabled(Value == false);
}
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("LABEL_ANGLE_ATTRIB")) )
{
pParameters->Get_Parameter("LABEL_ANGLE")->Set_Enabled(pParameter->asInt() >= Get_Shapes()->Get_Field_Count());
}
}
return( CWKSP_Shapes::On_Parameter_Changed(pParameters, pParameter, Flags) );
}
//---------------------------------------------------------
TSG_Rect CWKSP_Shapes::Edit_Get_Extent(void)
{
if( m_Edit_pShape )
{
return( m_Edit_pShape->Get_Extent() );
}
if( Get_Shapes()->Get_Selection_Count() > 0 )
{
return( Get_Shapes()->Get_Selection_Extent().m_rect );
}
return( Get_Shapes()->Get_Extent() );
}
//---------------------------------------------------------
bool CWKSP_Shapes::_Edit_Shape_Add(void)
{
if( !m_Edit_pShape )
{
if( Get_Shapes()->Get_Selection_Count() > 0 )
{
Get_Shapes()->Select(); // deselect
}
m_Edit_pShape = m_Edit_Shapes.Add_Shape();
return( _Edit_Part_Add() );
}
return( false );
}
//---------------------------------------------------------
bool CWKSP_Shapes::_Edit_Shape_Start(void)
{
if( m_Edit_pShape == NULL && Get_Shapes()->Get_Selection(m_Edit_Index) != NULL )
{
m_Edit_Mode = EDIT_SHAPE_MODE_Normal;
m_Edit_pShape = m_Edit_Shapes.Add_Shape(Get_Shapes()->Get_Selection(m_Edit_Index), SHAPE_COPY_GEOM);
m_Edit_iPart = -1;
m_Edit_iPoint = -1;
Update_Views(false);
return( true );
}
return( false );
}
//---------------------------------------------------------
void CQuadTree_Structure::Get_Shapes(CSG_Shapes *pShapes, CSG_PRQuadTree_Item *pItem, int Level)
{
if( pItem )
{
if( pShapes->Get_Type() == SHAPE_TYPE_Line )
{
if( pItem->is_Node() )
{
CSG_Shape *pShape = pShapes->Add_Shape();
pShape->Set_Value(0, Level);
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yCenter(), 0);
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yCenter(), 0);
pShape->Add_Point(pItem->Get_xCenter(), pItem->Get_yMin(), 1);
pShape->Add_Point(pItem->Get_xCenter(), pItem->Get_yMax(), 1);
for(int i=0; i<4; i++)
{
Get_Shapes(pShapes, pItem->asNode()->Get_Child(i), Level + 1);
}
}
}
if( pShapes->Get_Type() == SHAPE_TYPE_Polygon )
{
if( pItem->is_Node() )
{
for(int i=0; i<4; i++)
{
Get_Shapes(pShapes, pItem->asNode()->Get_Child(i), Level + 1);
}
}
else // if( pItem->is_Leaf() )
{
CSG_Shape *pShape = pShapes->Add_Shape();
pShape->Set_Value(0, Level + 1);
pShape->Set_Value(1, pItem->asLeaf()->Get_Z());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMin());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMin());
}
}
}
}
//---------------------------------------------------------
bool CWKSP_Shapes_Point::Get_Style_Size(int &min_Size, int &max_Size, double &min_Value, double &dValue, wxString *pName)
{
if( m_iSize >= 0 )
{
min_Size = (int)(m_Size);
max_Size = (int)(m_Size + (Get_Shapes()->Get_Maximum(m_iSize) - m_Size_Min) * m_dSize);
min_Value = m_Size_Min;
dValue = m_dSize;
if( pName )
{
pName->Printf(Get_Shapes()->Get_Field_Name(m_iSize));
}
return( true );
}
return( false );
}
//---------------------------------------------------------
wxMenu * CWKSP_Shapes::Edit_Get_Menu(void)
{
wxMenu *pMenu = new wxMenu;
CMD_Menu_Add_Item(pMenu, true , ID_CMD_SHAPES_EDIT_SHAPE);
if( !is_Editing() )
{
pMenu->AppendSeparator();
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_ADD_SHAPE);
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_DEL_SHAPE);
pMenu->AppendSeparator();
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_SEL_INVERT);
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_SEL_CLEAR);
if( Get_Shapes()->Get_Selection_Count() > 1
&& Get_Shapes()->Get_Type() != SHAPE_TYPE_Point )
{
pMenu->AppendSeparator();
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_MERGE);
}
if( Get_Shapes()->Get_Selection_Count() == 1
&& (Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon
|| Get_Shapes()->Get_Type() == SHAPE_TYPE_Line) )
{
pMenu->AppendSeparator();
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_SPLIT);
}
}
else if( Get_Shapes()->Get_Type() != SHAPE_TYPE_Point )
{
pMenu->AppendSeparator();
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_ADD_PART);
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_DEL_PART);
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_DEL_POINT);
pMenu->AppendSeparator();
if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Line
|| Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon )
{
CMD_Menu_Add_Item(pMenu, false, ID_CMD_SHAPES_EDIT_SPLIT);
}
CMD_Menu_Add_Item(pMenu, true, ID_CMD_SHAPES_EDIT_MOVE);
}
return( pMenu );
}
//---------------------------------------------------------
void CWKSP_Shapes::_Edit_Snap_Point(CSG_Point &Point, double ClientToWorld)
{
if( m_Edit_pShape )
{
CSG_Parameter_Shapes_List *pList = m_Parameters("EDIT_SNAP_LIST")->asShapesList();
if( pList->Get_Count() > 0 )
{
int i;
double snap_Dist, max_Dist;
CSG_Point snap_Point;
max_Dist = m_Parameters("EDIT_SNAP_DIST")->asDouble() * ClientToWorld;
snap_Dist = max_Dist + 1.0;
for(i=0; i<pList->Get_Count(); i++)
{
_Edit_Snap_Point(Point, snap_Point, snap_Dist, pList->asShapes(i), false);
}
if( snap_Dist <= max_Dist )
{
Point = snap_Point;
}
else if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Line || Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon )
{
for(i=0; i<pList->Get_Count(); i++)
{
_Edit_Snap_Point(Point, snap_Point, snap_Dist, pList->asShapes(i), true);
}
if( snap_Dist <= max_Dist )
{
Point = snap_Point;
}
}
}
}
}
//---------------------------------------------------------
bool CWKSP_Shapes::_Edit_Merge(void)
{
if( Get_Shapes()->Get_Selection_Count() < 2 || Get_Shapes()->Get_Type() == SHAPE_TYPE_Point )
{
return( false );
}
//-----------------------------------------------------
CSG_Shape *pMerged = Get_Shapes()->Get_Selection(0);
for(int i=1; i<Get_Shapes()->Get_Selection_Count(); i++)
{
CSG_Shape *pShape = Get_Shapes()->Get_Selection(i);
for(int iPart=0, jPart=pMerged->Get_Part_Count(); iPart<pShape->Get_Part_Count(); iPart++, jPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
pMerged->Add_Point(pShape->Get_Point(iPoint, iPart), jPart);
}
}
}
if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon )
{
SG_Polygon_Dissolve(pMerged);
}
Get_Shapes()->Select(pMerged, true);
Get_Shapes()->Del_Selection();
Get_Shapes()->Select(pMerged, false);
Update_Views(true);
return( true );
}
//---------------------------------------------------------
bool CWKSP_Shapes::Edit_Set_Attributes(void)
{
CSG_Table_Record *pSelection = Get_Shapes()->Get_Selection(m_Edit_Index);
if( pSelection )
{
for(int i=0; i<m_Edit_Attributes.Get_Record_Count(); i++)
{
if( !pSelection->Set_Value(i, m_Edit_Attributes.Get_Record(i)->asString(1)) )
{
m_Edit_Attributes.Get_Record(i)->Set_Value(1, pSelection->asString(i));
}
}
Update_Views(false);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CQuadTree_Structure::Get_Shapes(CSG_Shapes *pShapes, CSG_PRQuadTree_Item *pItem, TSG_Shape_Type Type)
{
CSG_Shape *pShape;
if( pItem )
{
switch( Type )
{
default:
return( false );
case SHAPE_TYPE_Line:
pShapes->Create(SHAPE_TYPE_Line, _TL("QuadTree - Lines"));
pShapes->Add_Field("LEVEL", SG_DATATYPE_Int);
pShape = pShapes->Add_Shape();
pShape->Set_Value(0, 0.0);
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMin());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMin());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMin());
break;
case SHAPE_TYPE_Polygon:
pShapes->Create(SHAPE_TYPE_Polygon, _TL("QuadTree - Squares"));
pShapes->Add_Field("LEVEL", SG_DATATYPE_Int);
pShapes->Add_Field("VALUE", SG_DATATYPE_Double);
break;
}
Get_Shapes(pShapes, pItem, 1);
return( true );
}
return( false );
}
//---------------------------------------------------------
void CWKSP_Shapes::_Edit_Snap_Point(CSG_Point Point, CSG_Point &snap_Point, double &snap_Dist, CSG_Shapes *pShapes, bool bLine)
{
CSG_Shape *pSelected = pShapes->Get_Selection(m_Edit_Index);
if( pShapes->Select(CSG_Rect(Point.Get_X() - snap_Dist, Point.Get_Y() - snap_Dist, Point.Get_X() + snap_Dist, Point.Get_Y() + snap_Dist)) )
{
for(int i=0; i<pShapes->Get_Selection_Count(); i++)
{
if( pShapes != Get_Shapes() || pSelected != pShapes->Get_Selection(i) )
{
if( bLine )
{
Edit_Snap_Point_ToLine(Point, snap_Point, snap_Dist, pShapes->Get_Selection(i));
}
else
{
_Edit_Snap_Point (Point, snap_Point, snap_Dist, pShapes->Get_Selection(i));
}
}
}
}
pShapes->Select(pSelected);
}
//---------------------------------------------------------
bool CWKSP_Shapes::_Edit_Split(void)
{
if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon
|| Get_Shapes()->Get_Type() == SHAPE_TYPE_Line )
{
switch( m_Edit_Mode )
{
default:
break;
//-------------------------------------------------
case EDIT_SHAPE_MODE_Normal:
m_Edit_Mode = EDIT_SHAPE_MODE_Split;
if( m_Edit_Shapes.Get_Count() == 0 )
{
m_Edit_Shapes.Add_Shape(Get_Shapes()->Get_Selection());
}
if( m_Edit_Shapes.Get_Count() > 1 )
{
m_Edit_Shapes.Get_Shape(1)->Del_Parts();
}
else
{
m_Edit_Shapes.Add_Shape();
}
return( true );
//-------------------------------------------------
case EDIT_SHAPE_MODE_Split:
m_Edit_Mode = EDIT_SHAPE_MODE_Normal;
CSG_Module *pModule = Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon
? SG_Get_Module_Library_Manager().Get_Module(SG_T("shapes_polygons"), 8) // Polygon-Line Intersection
: SG_Get_Module_Library_Manager().Get_Module(SG_T("shapes_lines" ), 6); // Split Lines with Lines
if( pModule )
{
CSG_Shapes Line(SHAPE_TYPE_Line), Split(Get_Shapes()->Get_Type());
Line.Add_Shape();
for(int i=0; i<m_Edit_Shapes.Get_Shape(1)->Get_Point_Count(); i++)
{
Line.Get_Shape(0)->Add_Point(m_Edit_Shapes.Get_Shape(1)->Get_Point(i));
}
m_Edit_Shapes.Del_Shape(1);
//-----------------------------------------
bool bResult;
CSG_Parameters P; P.Assign(pModule->Get_Parameters());
pModule->Set_Manager(NULL);
if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon )
{
bResult = pModule->Get_Parameters()->Set_Parameter("POLYGONS" , &m_Edit_Shapes)
&& pModule->Get_Parameters()->Set_Parameter("LINES" , &Line)
&& pModule->Get_Parameters()->Set_Parameter("INTERSECT", &Split)
&& pModule->Execute();
}
else // if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Line )
{
bResult = pModule->Get_Parameters()->Set_Parameter("LINES" , &m_Edit_Shapes)
&& pModule->Get_Parameters()->Set_Parameter("SPLIT" , &Line)
&& pModule->Get_Parameters()->Set_Parameter("INTERSECT", &Split)
&& pModule->Execute();
}
//-----------------------------------------
if( bResult )
{
if( m_Edit_pShape )
{
m_Edit_pShape->Assign(Split.Get_Shape(0), false);
for(int iSplit=1; iSplit<Split.Get_Count(); iSplit++)
{
CSG_Shape *pSplit = Split.Get_Shape(iSplit);
for(int iPart=0; iPart<pSplit->Get_Part_Count(); iPart++)
{
for(int iPoint=0, jPart=m_Edit_pShape->Get_Part_Count(); iPoint<pSplit->Get_Point_Count(iPart); iPoint++)
{
m_Edit_pShape->Add_Point(pSplit->Get_Point(iPoint, iPart), jPart);
}
}
}
}
else if( Get_Shapes()->Get_Selection_Count() == 1 ) // if( !m_Edit_pShape )
{
CSG_Shape *pSelection = Get_Shapes()->Get_Selection();
pSelection->Assign(Split.Get_Shape(0), false);
for(int iSplit=1; iSplit<Split.Get_Count(); iSplit++)
{
CSG_Shape *pSplit = Get_Shapes()->Add_Shape(Split.Get_Shape(iSplit));
((CSG_Table_Record *)pSplit)->Assign(pSelection);
Get_Shapes()->Select(pSplit, true);
}
m_Edit_Shapes.Del_Shapes();
}
}
pModule->Get_Parameters()->Assign_Values(&P);
pModule->Set_Manager(P.Get_Manager());
}
Update_Views(false);
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool CWKSP_Shapes::Edit_On_Mouse_Up(CSG_Point Point, double ClientToWorld, int Key)
{
//-----------------------------------------------------
if( Key & MODULE_INTERACTIVE_KEY_RIGHT )
{
switch( m_Edit_Mode )
{
case EDIT_SHAPE_MODE_Split:
return( _Edit_Split() );
case EDIT_SHAPE_MODE_Normal:
if( m_Edit_pShape && m_Edit_iPart >= 0 && m_Edit_iPoint < 0 )
{
m_Edit_iPart = -1;
Update_Views(false);
return( true );
}
break;
}
}
//-----------------------------------------------------
else if( m_Edit_pShape )
{
if( m_Edit_Mode == EDIT_SHAPE_MODE_Move )
{
if( m_Edit_Shapes.Get_Count() > 1 && m_Edit_Shapes.Get_Shape(1)->Get_Point_Count() > 0 )
{
m_Edit_Shapes.Get_Shape(1)->Add_Point(Point);
return( _Edit_Move(false) );
}
}
else if( m_Edit_iPart >= 0 )
{
if( m_Edit_iPoint >= 0 )
{
if( Point != m_Edit_Mouse_Down )
{
_Edit_Snap_Point(Point, ClientToWorld);
m_Edit_pShape->Set_Point(Point, m_Edit_iPoint, m_Edit_iPart);
Update_Views(false);
return( true );
}
}
else
{
_Edit_Snap_Point(Point, ClientToWorld);
m_Edit_pShape->Add_Point(Point, m_Edit_iPart);
Update_Views(false);
return( true );
}
}
}
//-----------------------------------------------------
else if( m_Edit_Mode == EDIT_SHAPE_MODE_Normal )
{
g_pACTIVE->Get_Attributes()->Save_Changes(true);
CSG_Rect rWorld(m_Edit_Mouse_Down, Point);
if( rWorld.Get_XRange() == 0.0 && rWorld.Get_YRange() == 0.0 )
{
rWorld.Inflate(2.0 * ClientToWorld, false);
}
int Count = Get_Shapes()->Get_Selection_Count();
Get_Shapes()->Select(rWorld, (Key & MODULE_INTERACTIVE_KEY_CTRL) != 0);
Edit_Set_Index((Key & MODULE_INTERACTIVE_KEY_CTRL) == 0 ? 0 :
Count < Get_Shapes()->Get_Selection_Count() || m_Edit_Index >= Get_Shapes()->Get_Selection_Count()
? Get_Shapes()->Get_Selection_Count() - 1 : m_Edit_Index
);
if( m_pTable->Get_View() )
{
m_pTable->Get_View()->Update_Selection();
}
Update_Views(false);
return( true );
}
return( false );
}
