00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include "a2dprec.h"
00014
00015 #ifdef __BORLANDC__
00016 #pragma hdrstop
00017 #endif
00018
00019 #ifndef WX_PRECOMP
00020 #include "wx/wx.h"
00021 #endif
00022
00023 #if defined(__WXMSW__) && defined(__MEMDEBUG__)
00024 #include <wx/msw/msvcrt.h>
00025 #endif
00026
00027 #include "wx/canvas/cancom.h"
00028 #include "wx/canvas/drawer.h"
00029 #include "wx/canvas/canvas.h"
00030 #include "wx/canvas/polygon.h"
00031 #include "wx/canvas/canglob.h"
00032 #include "wx/canvas/algos.h"
00033
00034 #include <wx/numdlg.h>
00035
00036
00037
00038
00039
00040
00041
00042
00043 a2dCentralCanvasCommandProcessor* a2dGetCmdh()
00044 {
00045 return wxDynamicCast( a2dDocviewGlobals->GetDocviewCommandProcessor(), a2dCentralCanvasCommandProcessor );
00046 }
00047
00048
00049 a2dDrawer2D* a2dGetDrawer2D()
00050 {
00051 return a2dGetCmdh()->CheckDrawer()->GetDrawer2D();
00052 }
00053
00054 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_AddObject, a2dCommand )
00055 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ReleaseObject, a2dCommand )
00056 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ReplaceObject, a2dCommand )
00057 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetFlags, a2dCommand )
00058 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetFlag, a2dCommand )
00059 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetSelectFlag, a2dCommand )
00060 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_TransformMask, a2dCommand )
00061 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_AddPoint, a2dCommand )
00062 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_MoveSegment, a2dCommand )
00063 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_MoveMidSegment, a2dCommand )
00064 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_RemoveSegment, a2dCommand )
00065 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetSegments, a2dCommand )
00066 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ChangeText, a2dCommand )
00067 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ChangeCentralStyle, a2dCommand )
00068 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ChangeCanvasObjectStyle, a2dCommand )
00069 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetCanvasProperty, a2dCommand_SetProperty )
00070 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ConnectPins, a2dCommand )
00071 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_Select, a2dCommand )
00072 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_Zoom, a2dCommand )
00073 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_GroupAB, a2dCommand )
00074 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetLayerGroup, a2dCommand )
00075 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetLayer, a2dCommand )
00076 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetTarget, a2dCommand )
00077 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetDrawWireFrame, a2dCommand )
00078 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_DrawGridLines, a2dCommand )
00079 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_DrawGridAtFront, a2dCommand )
00080 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_DrawGrid, a2dCommand )
00081 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetSnap, a2dCommand )
00082 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetSnapFeatures, a2dCommand )
00083 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetSnapFeature, a2dCommand )
00084 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetFont, a2dCommand )
00085 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetStroke, a2dCommand )
00086 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetFill, a2dCommand )
00087 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetStrokeColour, a2dCommand )
00088 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetFillColour, a2dCommand )
00089 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_Refresh, a2dCommand )
00090 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_GdsIoSaveTextAsPolygon, a2dCommand )
00091 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_KeyIoSaveTextAsPolygon, a2dCommand )
00092 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ViewAsImage, a2dCommand )
00093 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ViewAsSvg, a2dCommand )
00094 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_PushInto, a2dCommand )
00095 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_NewGroup, a2dCommand )
00096 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_NewPin, a2dCommand )
00097 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetShowObject, a2dCommand )
00098 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetCursor, a2dCommand )
00099 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetRelativeStart, a2dCommand )
00100 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_AddMeasurement, a2dCommand )
00101 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ClearMeasurements, a2dCommand )
00102 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_GdsIoSaveFromView, a2dCommand )
00103 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_KeyIoSaveFromView, a2dCommand )
00104 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetLayerMask, a2dCommand )
00105 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_DeleteMask, a2dCommand )
00106 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ToTopMask, a2dCommand )
00107 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ToBackMask, a2dCommand )
00108 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_CopyMask, a2dCommand )
00109 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_MoveMask, a2dCommand )
00110 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ConvertMask, a2dCommand )
00111 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_GroupMask, a2dCommand )
00112 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_UnGroupMask, a2dCommand )
00113 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_MergeMask, a2dCommand )
00114 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_PolygonToSurfaceMask, a2dCommand )
00115 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SurfaceToPolygonMask, a2dCommand )
00116 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_OffsetMask, a2dCommand )
00117 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_UrlOnMask, a2dCommand )
00118 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetFillStrokeMask, a2dCommand )
00119 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_ImagesToRectMask, a2dCommand )
00120 IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetLayersProperty, a2dCommand )
00121
00122
00123 const a2dCommandId a2dCommand_AddObject::Id( wxT("AddObject") );
00124 const a2dCommandId a2dCommand_ReleaseObject::Id( wxT("ReleaseObject") );
00125 const a2dCommandId a2dCommand_ReplaceObject::Id( wxT("ReplaceObject") );
00126 const a2dCommandId a2dCommand_SetFlags::Id( wxT("SetFlags") );
00127 const a2dCommandId a2dCommand_SetFlag::Id( wxT("SetFlag") );
00128 const a2dCommandId a2dCommand_SetSelectFlag::Id( wxT("SetSelectFlag") );
00129 const a2dCommandId a2dCommand_TransformMask::Id( wxT("SetTransformFlaged") );
00130 const a2dCommandId a2dCommand_AddPoint::Id( wxT("AddPoint") );
00131 const a2dCommandId a2dCommand_MoveSegment::Id( wxT("MoveSegment") );
00132 const a2dCommandId a2dCommand_MoveMidSegment::Id( wxT("MoveMidSegment") );
00133 const a2dCommandId a2dCommand_RemoveSegment::Id( wxT("RemoveSegment") );
00134 const a2dCommandId a2dCommand_SetSegments::Id( wxT("SetSegments") );
00135 const a2dCommandId a2dCommand_ChangeText::Id( wxT("ChangeText") );
00136 const a2dCommandId a2dCommand_ChangeCanvasObjectStyle::Id( wxT("ChangeCanvasObjectStyle") );
00137 const a2dCommandId a2dCommand_ChangeCentralStyle::Id( wxT("ChangeCentralStyle") );
00138 const a2dCommandId a2dCommand_SetCanvasProperty::Id( wxT("SetCanvasProperty") );
00139 const a2dCommandId a2dCommand_ConnectPins::Id( wxT("ConnectPins") );
00140 const a2dCommandId a2dCommand_Select::Id( wxT("Select") );
00141 const a2dCommandId a2dCommand_Zoom::Id( wxT("Zoom") );
00142 const a2dCommandId a2dCommand_GroupAB::Id( wxT("GroupAB") );
00143 const a2dCommandId a2dCommand_SetLayerGroup::Id( wxT("SetLayerGroup") );
00144 const a2dCommandId a2dCommand_SetLayer::Id( wxT("SetLayer") );
00145 const a2dCommandId a2dCommand_SetTarget::Id( wxT("SetTarget") );
00146 const a2dCommandId a2dCommand_SetDrawWireFrame::Id( wxT("SetDrawWireFrame") );
00147 const a2dCommandId a2dCommand_DrawGridLines::Id( wxT("DrawGridLines") );
00148 const a2dCommandId a2dCommand_DrawGridAtFront::Id( wxT("DrawGridAtFront") );
00149
00150
00151 const a2dCommandId a2dCommand_DrawGrid::Id( wxT("DrawGrid") );
00152 const a2dCommandId a2dCommand_SetSnap::Id( wxT("SetSnap") );
00153 const a2dCommandId a2dCommand_SetSnapFeatures::Id( wxT("SetSnapFeatures") );
00154 const a2dCommandId a2dCommand_SetSnapFeature::Id( wxT("SetSnapFeature") );
00155 const a2dCommandId a2dCommand_SetFont::Id( wxT("SetFont") );
00156 const a2dCommandId a2dCommand_SetStroke::Id( wxT("SetStroke") );
00157 const a2dCommandId a2dCommand_SetFill::Id( wxT("SetFill") );
00158 const a2dCommandId a2dCommand_SetStrokeColour::Id( wxT("SetStrokeColour") );
00159 const a2dCommandId a2dCommand_SetFillColour::Id( wxT("SetFillColour") );
00160 const a2dCommandId a2dCommand_SetContourWidth::Id( wxT("SetContourWidth") );
00161 const a2dCommandId a2dCommand_SetPathType::Id( wxT("SetPathType") );
00162
00163 const a2dCommandId a2dCommand_Refresh::Id( wxT("Refresh") );
00164 const a2dCommandId a2dCommand_GdsIoSaveTextAsPolygon::Id( wxT("GdsIoSaveTextAsPolygon") );
00165 const a2dCommandId a2dCommand_KeyIoSaveTextAsPolygon::Id( wxT("KeyIoSaveTextAsPolygon") );
00166
00167 const a2dCommandId a2dCommand_ViewAsImage::Id( wxT("ViewAsImage") );
00168 const a2dCommandId a2dCommand_ViewAsSvg::Id( wxT("ViewAsSvg") );
00169 const a2dCommandId a2dCommand_PushInto::Id( wxT("PushInto") );
00170 const a2dCommandId a2dCommand_NewGroup::Id( wxT("NewGroup") );
00171 const a2dCommandId a2dCommand_NewPin::Id( wxT("NewPin") );
00172 const a2dCommandId a2dCommand_SetShowObject::Id( wxT("SetShowObject") );
00173 const a2dCommandId a2dCommand_SaveLayers::Id( wxT("SaveLayers") );
00174 const a2dCommandId a2dCommand_LoadLayers::Id( wxT("LoadLayers") );
00175
00176 const a2dCommandId a2dCommand_SetCursor::Id( wxT("SetCursor") );
00177 const a2dCommandId a2dCommand_SetRelativeStart::Id( wxT("SetRelativeStart") );
00178 const a2dCommandId a2dCommand_AddMeasurement::Id( wxT("AddMeasurement") );
00179 const a2dCommandId a2dCommand_ClearMeasurements::Id( wxT("ClearMeasurements") );
00180
00181 const a2dCommandId a2dCommand_GdsIoSaveFromView::Id( wxT("GdsIoSaveFromView") );
00182 const a2dCommandId a2dCommand_KeyIoSaveFromView::Id( wxT("KeyIoSaveFromView") );
00183 const a2dCommandId a2dCommand_SetLayerMask::Id( wxT("SetLayerMask") );
00184 const a2dCommandId a2dCommand_DeleteMask::Id( wxT("DeleteMask") );
00185 const a2dCommandId a2dCommand_ToTopMask::Id( wxT("ToTopMask") );
00186 const a2dCommandId a2dCommand_ToBackMask::Id( wxT("ToBackMask") );
00187 const a2dCommandId a2dCommand_CopyMask::Id( wxT("CopyMask") );
00188 const a2dCommandId a2dCommand_MoveMask::Id( wxT("MoveMask") );
00189 const a2dCommandId a2dCommand_ConvertMask::Id( wxT("ConvertMask") );
00190 const a2dCommandId a2dCommand_GroupMask::Id( wxT("GroupMask") );
00191 const a2dCommandId a2dCommand_UnGroupMask::Id( wxT("UnGroupMask") );
00192 const a2dCommandId a2dCommand_MergeMask::Id( wxT("MergeMask") );
00193 const a2dCommandId a2dCommand_PolygonToSurfaceMask::Id( wxT("PolygonToSurfaceMask") );
00194 const a2dCommandId a2dCommand_SurfaceToPolygonMask::Id( wxT("SurfaceToPolygonMask") );
00195 const a2dCommandId a2dCommand_OffsetMask::Id( wxT("OffsetMask") );
00196 const a2dCommandId a2dCommand_UrlOnMask::Id( wxT("UrlOnMask") );
00197 const a2dCommandId a2dCommand_SetFillStrokeMask::Id( wxT("SetFillStrokeMask") );
00198 const a2dCommandId a2dCommand_ImagesToRectMask::Id( wxT("ImagesToRect") );
00199 const a2dCommandId a2dCommand_SetLayersProperty::Id( wxT("SetLayersProperty") );
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209 const a2dMenuIdItem CmdMenu_ChangeCanvasObjectStyle( wxT("CmdMenu_ChangeCanvasObjectStyle") );
00210 const a2dMenuIdItem CmdMenu_ChangeCentralStyle( wxT("CmdMenu_ChangeCentralStyle") );
00211 const a2dMenuIdItem CmdMenu_SetLayer( wxT("CmdMenu_SetLayer"), _("Set Current layer"), _("set the current layer for drawing upon") );
00212 const a2dMenuIdItem CmdMenu_SetTarget( wxT("CmdMenu_SetTarget"), _("Set Current Target layer"), _("set the current target layer for actions involving a target") );
00213
00214 const a2dMenuIdItem CmdMenu_SetDrawWireFrame( wxT("CmdMenu_SetDrawWireFrame"), _("Draw only outlines"), _("Document drawn in outlines"), wxITEM_CHECK );
00215 const a2dMenuIdItem CmdMenu_DrawGridLines( wxT("CmdMenu_DrawGridLines"), _("Show Grid as Lines"), _("Grid lines instead of points"), wxITEM_CHECK );
00216 const a2dMenuIdItem CmdMenu_DrawGridAtFront( wxT("CmdMenu_DrawGridAtFront"), _("Grid on top or back"), _("draw grid on top or back of drawing"), wxITEM_CHECK );
00217 const a2dMenuIdItem CmdMenu_DrawGrid( wxT("CmdMenu_DrawGrid"), _("Show Grid"), _("Grid On Off"), wxITEM_CHECK );
00218 const a2dMenuIdItem CmdMenu_SetSnap( wxT("CmdMenu_SetSnap"), _("Snap wile drawing"), _("snap inside tools while drawing"), wxITEM_CHECK );
00219 const a2dMenuIdItem CmdMenu_SetYAxis( wxT("CmdMenu_SetYAxis"), _("Set YAxis up or down"), _("Set YAxis up or down"), wxITEM_CHECK );
00220 const a2dMenuIdItem CmdMenu_Option_SplinePoly( wxT("CmdMenu_Option_SplinePoly"), _("Spline Poly"), _("draw polygons/lines splined or not"), wxITEM_CHECK );
00221 const a2dMenuIdItem CmdMenu_Option_CursorCrosshair( wxT("CmdMenu_Option_CursorCrosshair"), _("Crosshair Cursor"), _("croshair cursor used in tools"), wxITEM_CHECK );
00222 const a2dMenuIdItem CmdMenu_Option_RescaleAtReSize( wxT("CmdMenu_Option_RescaleAtReSize"), _("ReScale On ReSize"), _("Set rescale after resize"), wxITEM_CHECK );
00223 const a2dMenuIdItem CmdMenu_Option_ReverseLayers( wxT("CmdMenu_Option_ReverseLayers"), _("Reverse layers"), _("Draw layers reversed"), wxITEM_CHECK );
00224
00225 const a2dMenuIdItem CmdMenu_SetSnapFeatures( wxT("CmdMenu_SetSnapFeatures") );
00226 const a2dMenuIdItem CmdMenu_SetSnapFeature( wxT("CmdMenu_SetSnapFeature") );
00227 const a2dMenuIdItem CmdMenu_SetStroke( wxT("CmdMenu_SetStroke") );
00228 const a2dMenuIdItem CmdMenu_SetFill( wxT("CmdMenu_SetFill") );
00229 const a2dMenuIdItem CmdMenu_SetStrokeColour( wxT("CmdMenu_SetStrokeColour") );
00230 const a2dMenuIdItem CmdMenu_SetFillColour( wxT("CmdMenu_SetFillColour") );
00231 const a2dMenuIdItem CmdMenu_SetContourWidth( wxT("CmdMenu_SetContourWidth") );
00232 const a2dMenuIdItem CmdMenu_SetPathType( wxT("CmdMenu_SetPathType") );
00233 const a2dMenuIdItem CmdMenu_SetNormalizeFactor( wxT("CmdMenu_SetNormalizeFactor"), _("Set Normalize factor"), _("scale normalized objects by this") );
00234
00235 const a2dMenuIdItem CmdMenu_Refresh( wxT("CmdMenu_Refresh"), _("refresh"), _("refresh all that is drawn on the canvas") );
00236 const a2dMenuIdItem CmdMenu_ZoomOut( wxT("CmdMenu_ZoomOut"), _("Zoom out"), _("zoom out to see whole drawing at currently shown object") );
00237 const a2dMenuIdItem CmdMenu_ZoomOut2( wxT("CmdMenu_ZoomOut2"), _("Zoom out factor 2"), _("zoom out to see twice as much") );
00238 const a2dMenuIdItem CmdMenu_ZoomIn2( wxT("CmdMenu_ZoomIn2"), _("Zoom in factor 2"), _("zoom in a factor of two") );
00239 const a2dMenuIdItem CmdMenu_EmptyShownObject( wxT("CmdMenu_EmptyShownObject"), _("Empty Shown Object"), _("remove children of shown object") );
00240 const a2dMenuIdItem CmdMenu_GdsIoSaveTextAsPolygon( wxT("CmdMenu_GdsIoSaveTextAsPolygon"), _("Gdsii Save text as Polgyon"), _("When possible/implemented, save text as polygon in GdsII format"), wxITEM_CHECK );
00241 const a2dMenuIdItem CmdMenu_KeyIoSaveTextAsPolygon( wxT("CmdMenu_KeyIoSaveTextAsPolygon"), _("Key Save text as Polgyon"), _("When possible/implemented, save text as polygon in KEY format"), wxITEM_CHECK );
00242 const a2dMenuIdItem CmdMenu_SetGdsIoSaveFromView( wxT("CmdMenu_SetGdsIoSaveFromView"), _("Gdsii Save from View down"), _("Structure visible and all down will be saved"), wxITEM_CHECK );
00243 const a2dMenuIdItem CmdMenu_SetKeyIoSaveFromView( wxT("CmdMenu_SetKeyIoSaveFromView"), _("Key Save from View down"), _("Structure visible and all down will be saved"), wxITEM_CHECK );
00244
00245 const a2dMenuIdItem CmdMenu_PushInto( wxT("CmdMenu_PushInto"), _("push into selected"), _("make the object contained the visible object") );
00246 const a2dMenuIdItem CmdMenu_NewGroup( wxT("CmdMenu_NewGroup"), _("new group"), _("create new group and set it as the current to show") );
00247 const a2dMenuIdItem CmdMenu_NewPin( wxT("CmdMenu_NewPin"), _("new pin"), _("insert new pin in group") );
00248 const a2dMenuIdItem CmdMenu_SaveLayers( wxT("CmdMenu_SaveLayers"), _("SaveLayers"), _("Save layers to a layer file") );
00249 const a2dMenuIdItem CmdMenu_SaveLayersHome( wxT("CmdMenu_SaveLayersHome"), _("SaveLayers Home"), _("Save layers to a layer file") );
00250 const a2dMenuIdItem CmdMenu_SaveLayersLastDir( wxT("CmdMenu_SaveLayersLastDir"), _("SaveLayers LastDir"), _("Save layers to a layer file") );
00251 const a2dMenuIdItem CmdMenu_SaveLayersCurrentDir( wxT("CmdMenu_SaveLayersCurrentDir"), _("SaveLayers Current Dir"), _("Save layers to a layer file") );
00252
00253 const a2dMenuIdItem CmdMenu_LoadLayers( wxT("CmdMenu_LoadLayers"), _("LoadLayers"), _("Load layers to a layer file") );
00254 const a2dMenuIdItem CmdMenu_LoadLayersHome( wxT("CmdMenu_LoadLayersHome"), _("LoadLayers Home"), _("Load layers to a layer file") );
00255 const a2dMenuIdItem CmdMenu_LoadLayersLastDir( wxT("CmdMenu_LoadLayersLastDir"), _("LoadLayers LastDir"), _("Load layers to a layer file") );
00256 const a2dMenuIdItem CmdMenu_LoadLayersCurrentDir( wxT("CmdMenu_LoadLayersCurrentDir"), _("LoadLayers Current Dir"), _("Load layers to a layer file") );
00257
00258 const a2dMenuIdItem CmdMenu_SetCursor( wxT("CmdMenu_SetCursor") );
00259 const a2dMenuIdItem CmdMenu_SetRelativeStart( wxT("CmdMenu_SetRelativeStart") );
00260 const a2dMenuIdItem CmdMenu_AddMeasurement( wxT("CmdMenu_AddMeasurement") );
00261 const a2dMenuIdItem CmdMenu_ClearMeasurements( wxT("CmdMenu_ClearMeasurements") );
00262
00263 const a2dMenuIdItem CmdMenu_GdsIoSaveFromView( wxT("CmdMenu_GdsIoSaveFromView"), _("Gdsii Save from View down"), _("Structure visible and all down will be saved"), wxITEM_CHECK );
00264 const a2dMenuIdItem CmdMenu_KeyIoSaveFromView( wxT("CmdMenu_KeyIoSaveFromView"), _("Key Save from View down"), _("Structure visible and all down will be saved"), wxITEM_CHECK );
00265 const a2dMenuIdItem CmdMenu_SetLayersProperty( wxT("CmdMenu_SetLayersProperty") );
00266
00267 const a2dMenuIdItem CmdMenu_Selected_SelectAll( wxT("CmdMenu_Selected_SelectAll"), _("select all objects"), _("select all objects visible") );
00268 const a2dMenuIdItem CmdMenu_Selected_DeSelectAll( wxT("CmdMenu_Selected_DeSelectAll"), _("deselect all objects"), _("deselect all objects visible") );
00269 const a2dMenuIdItem CmdMenu_Selected_Delete( wxT("CmdMenu_Selected_Delete"), _("delete selected"), _("delete selected objects") );
00270 const a2dMenuIdItem CmdMenu_Selected_Group( wxT("CmdMenu_Selected_Group"), _("group selected"), _("group selected objects") );
00271 const a2dMenuIdItem CmdMenu_Selected_ImageToRectangles( wxT("CmdMenu_Selected_ImageToRectangles"), _("selected images to rectangle"), _("selected images are converted to rectangles per pixel") );
00272 const a2dMenuIdItem CmdMenu_Selected_ToTop( wxT("CmdMenu_Selected_ToTop"), _("selected to top"), _("selected drawn first") );
00273 const a2dMenuIdItem CmdMenu_Selected_ToBack( wxT("CmdMenu_Selected_ToBack"), _("selected to back"), _("selected drawn last") );
00274 const a2dMenuIdItem CmdMenu_Selected_SetStyle( wxT("CmdMenu_Selected_SetStyle"), _("set fill stroke selected"), _("selected objects get the current fill and stroke") );
00275 const a2dMenuIdItem CmdMenu_Selected_ConvertToPolygonPolylinesWithArcs( wxT("CmdMenu_Selected_ConvertToPolygonPolylinesWithArcs"), _("convert shapes to polylines and polygons with Arcs"), _("selected primitive shapes will be converted to polygons/polylines if possible") );
00276 const a2dMenuIdItem CmdMenu_Selected_ConvertToPolygonPolylinesWithoutArcs( wxT("CmdMenu_Selected_ConvertToPolygonPolylinesWithoutArcs"), _("convert shapes to polylines and polygons"), _("selected primitive shapes will be converted to polygons/polylines if possible") );
00277 const a2dMenuIdItem CmdMenu_Selected_ConvertToPolylines( wxT("CmdMenu_Selected_ConvertToPolylines"), _("convert shapes to polylines"), _("selected primitive shapes will be converted to polylines if possible") );
00278 const a2dMenuIdItem CmdMenu_Selected_ConvertLinesArcs( wxT("CmdMenu_Selected_ConvertLinesArcs"), _("convert shapes to lines and arcs"), _("selected primitive shapes will be converted to arcs and lines if possible") );
00279 const a2dMenuIdItem CmdMenu_Selected_ConvertToVPaths( wxT("CmdMenu_Selected_ConvertToVPaths"), _("convert shapes to vector path"), _("selected primitive shapes will be converted to vector paths if possible") );
00280 const a2dMenuIdItem CmdMenu_Selected_ConvertPolygonToArcs( wxT("CmdMenu_Selected_ConvertPolygonToArcs"), _("detect arcs in polygons"), _("selected polygon shapes to polygons with arcs") );
00281 const a2dMenuIdItem CmdMenu_Selected_ConvertPolylineToArcs( wxT("CmdMenu_Selected_ConvertPolylineToArcs"), _("detect arcs in polylines"), _("selected polyline shapes to polylines with arcs") );
00282 const a2dMenuIdItem CmdMenu_Selected_ConvertPathToPolygon( wxT("CmdMenu_Selected_ConvertPathToPolygon"), _("Path2Polygon"), _("Convert Path to polygons") );
00283 const a2dMenuIdItem CmdMenu_Selected_ConvertSurfaceToPolygon( wxT("CmdMenu_Selected_ConvertSurfaceToPolygon"), _("Surface to Polygons"), _("convert selected surfaces shapes to polygons") );
00284 const a2dMenuIdItem CmdMenu_Selected_ConvertPolygonToSurface( wxT("CmdMenu_Selected_ConvertPolygonToSurface"), _("Polygons to Surface"), _("convert selected polygon shapes to surfaces") );
00285 const a2dMenuIdItem CmdMenu_Selected_UnGroup( wxT("CmdMenu_Selected_UnGroup"), _("ungroup selected one level"), _("ungroup selected one level") );
00286 const a2dMenuIdItem CmdMenu_Selected_UnGroupDeep( wxT("CmdMenu_Selected_UnGroupDeep"), _("ungroup selected deep"), _("ungroup selected deep") );
00287 const a2dMenuIdItem CmdMenu_Selected_Merge( wxT("CmdMenu_Selected_Merge"), _("MergeSelected"), _("Merge selected objects") );
00288 const a2dMenuIdItem CmdMenu_Selected_Offset( wxT("CmdMenu_Selected_Offset"), _("OffsetSelected"), _("Offset selected objects") );
00289 const a2dMenuIdItem CmdMenu_Selected_CreateRing( wxT("CmdMenu_Selected_CreateRing"), _("Create Ring"), _("Ring creation operation") );
00290
00291
00292 const a2dMenuIdItem CmdMenu_GroupAB_Offset( wxT("CmdMenu_GroupAB_Offset"), _("Offset"), _("Boolean Offset operation") );
00293 const a2dMenuIdItem CmdMenu_GroupAB_Smooth( wxT("CmdMenu_GroupAB_Smooth"), _("Smooth"), _("Smooth operation") );
00294 const a2dMenuIdItem CmdMenu_GroupAB_CreateRing( wxT("CmdMenu_GroupAB_CreateRing"), _("Create Ring"), _("Ring creation operation") );
00295 const a2dMenuIdItem CmdMenu_GroupAB_Delete( wxT("CmdMenu_GroupAB_Delete"), _("delete groupA"), _("delete groupA Objects") );
00296 const a2dMenuIdItem CmdMenu_GroupAB_Move( wxT("CmdMenu_GroupAB_Move"), _("move groupA"), _("move groupA Objects") );
00297 const a2dMenuIdItem CmdMenu_GroupAB_Copy( wxT("CmdMenu_GroupAB_Copy"), _("copy groupA"), _("copy groupA Objects") );
00298 const a2dMenuIdItem CmdMenu_GroupAB_ToArcs( wxT("CmdMenu_GroupAB_ToArcs"), _("toArcs groupA"), _("convert lines to arcs if possible in groupA Objects") );
00299 const a2dMenuIdItem CmdMenu_GroupAB_Or( wxT("CmdMenu_GroupAB_Or"), _("Boolean Or"), _("Boolean Or operation group A-B") );
00300 const a2dMenuIdItem CmdMenu_GroupAB_And( wxT("CmdMenu_GroupAB_And"), _("Boolean And"), _("Boolean And operation group A-B") );
00301 const a2dMenuIdItem CmdMenu_GroupAB_Exor( wxT("CmdMenu_GroupAB_Exor"), _("Boolean Exor"), _("Boolean Exor operation group A-B") );
00302 const a2dMenuIdItem CmdMenu_GroupAB_AsubB( wxT("CmdMenu_GroupAB_AsubB"), _("Boolean A-B"), _("Boolean Subtract operation group A-B") );
00303 const a2dMenuIdItem CmdMenu_GroupAB_BsubA( wxT("CmdMenu_GroupAB_BsubA"), _("Boolean B-A"), _("Boolean Subtract operation group A-B") );
00304 const a2dMenuIdItem CmdMenu_GroupAB_ConvertSurfaceToPolygon( wxT("CmdMenu_GroupAB_ConvertSurfaceToPolygon"), _("Surface to Polygons"), _("convert GroupA surfaces shapes to polygons") );
00305 const a2dMenuIdItem CmdMenu_GroupAB_ConvertPolygonToSurface( wxT("CmdMenu_GroupAB_ConvertPolygonToSurface"), _("Polygons to Surface"), _("convert GroupA polygon shapes to surfaces") );
00306
00307
00308
00309
00310
00311
00312
00313
00314 a2dPropertyIdBool* a2dCentralCanvasCommandProcessor::PROPID_PopBeforePush = NULL;
00315 a2dPropertyIdBool* a2dCentralCanvasCommandProcessor::PROPID_OneShotTools = NULL;
00316 a2dPropertyIdBool* a2dCentralCanvasCommandProcessor::PROPID_EditAtEndTools = NULL;
00317 a2dPropertyIdBool* a2dCentralCanvasCommandProcessor::PROPID_Spline = NULL;
00318 a2dPropertyIdUint16* a2dCentralCanvasCommandProcessor::PROPID_Layer = NULL;
00319 a2dPropertyIdFill* a2dCentralCanvasCommandProcessor::PROPID_Fill = NULL;
00320 a2dPropertyIdStroke* a2dCentralCanvasCommandProcessor::PROPID_Stroke = NULL;
00321 a2dPropertyIdFont* a2dCentralCanvasCommandProcessor::PROPID_Font = NULL;
00322 a2dPropertyIdCanvasObject* a2dCentralCanvasCommandProcessor::PROPID_Begin = NULL;
00323 a2dPropertyIdCanvasObject* a2dCentralCanvasCommandProcessor::PROPID_End = NULL;
00324 a2dPropertyIdDouble* a2dCentralCanvasCommandProcessor::PROPID_EndScaleX = NULL;
00325 a2dPropertyIdDouble* a2dCentralCanvasCommandProcessor::PROPID_EndScaleY = NULL;
00326 a2dPropertyIdBool* a2dCentralCanvasCommandProcessor::PROPID_Snap = NULL;
00327
00328 INITIALIZE_PROPERTIES( a2dCentralCanvasCommandProcessor, a2dDocumentCommandProcessor )
00329 {
00330 PROPID_Fill = new a2dPropertyIdFill( wxT("Fill"),
00331 a2dPropertyId::flag_transfer|a2dPropertyId::flag_listfirst|a2dPropertyId::flag_clonedeep,
00332 *a2dNullFILL,
00333 static_cast < a2dPropertyIdFill::ConstGet >(&a2dCentralCanvasCommandProcessor::MX_GetFill),
00334 static_cast < a2dPropertyIdFill::ConstSet >(&a2dCentralCanvasCommandProcessor::MX_SetFill) );
00335 AddPropertyId( PROPID_Fill );
00336
00337 PROPID_Stroke = new a2dPropertyIdStroke( wxT("Stroke"),
00338 a2dPropertyId::flag_transfer|a2dPropertyId::flag_listfirst|a2dPropertyId::flag_clonedeep,
00339 *a2dNullSTROKE,
00340 static_cast < a2dPropertyIdStroke::ConstGet >(&a2dCentralCanvasCommandProcessor::MX_GetStroke),
00341 static_cast < a2dPropertyIdStroke::ConstSet >(&a2dCentralCanvasCommandProcessor::MX_SetStroke) );
00342 AddPropertyId( PROPID_Stroke );
00343
00344 PROPID_Font = new a2dPropertyIdFont( wxT("Font"),
00345 a2dPropertyId::flag_transfer|a2dPropertyId::flag_clonedeep,
00346 *a2dNullFONT,
00347 static_cast < a2dPropertyIdFont::ConstGet >(&a2dCentralCanvasCommandProcessor::MX_GetFont),
00348 static_cast < a2dPropertyIdFont::ConstSet >(&a2dCentralCanvasCommandProcessor::MX_SetFont) );
00349 AddPropertyId( PROPID_Font );
00350
00351 A2D_PROPID_M( a2dPropertyIdCanvasObject, a2dCentralCanvasCommandProcessor, Begin, 0, m_currentBegin );
00352 A2D_PROPID_M( a2dPropertyIdCanvasObject, a2dCentralCanvasCommandProcessor, End, 0, m_currentEnd );
00353 A2D_PROPID_M( a2dPropertyIdDouble, a2dCentralCanvasCommandProcessor, EndScaleX, 0, m_currentXscale );
00354 A2D_PROPID_M( a2dPropertyIdDouble, a2dCentralCanvasCommandProcessor, EndScaleY, 0, m_currentYscale );
00355 A2D_PROPID_M( a2dPropertyIdBool, a2dCentralCanvasCommandProcessor, PopBeforePush, false, m_popBeforePush );
00356 A2D_PROPID_M( a2dPropertyIdBool, a2dCentralCanvasCommandProcessor, OneShotTools, false, m_oneShotTools );
00357 A2D_PROPID_M( a2dPropertyIdBool, a2dCentralCanvasCommandProcessor, EditAtEndTools, false, m_editAtEndTools );
00358 A2D_PROPID_M( a2dPropertyIdBool, a2dCentralCanvasCommandProcessor, Spline, false, m_spline );
00359 A2D_PROPID_D( a2dPropertyIdBool, Snap, false );
00360 A2D_PROPID_M( a2dPropertyIdUint16, a2dCentralCanvasCommandProcessor, Layer, false, m_layer );
00361
00362 return true;
00363 }
00364
00365 IMPLEMENT_CLASS( a2dCentralCanvasCommandProcessor, a2dDocumentCommandProcessor )
00366
00367 A2D_BEGIN_EVENT_TABLE( a2dCentralCanvasCommandProcessor, a2dDocumentCommandProcessor )
00368 A2D_EVT_ACTIVATE_VIEW( a2dCentralCanvasCommandProcessor::OnActivateView )
00369 A2D_EVT_BEGINBUSY( a2dCentralCanvasCommandProcessor::OnBusyBegin )
00370 A2D_EVT_ENDBUSY( a2dCentralCanvasCommandProcessor::OnBusyEnd )
00371 A2D_EVT_CHANGED_DOCUMENT( a2dCentralCanvasCommandProcessor::OnChangedDocument )
00372
00373 A2D_EVT_MENU( CmdMenu_Selected_Merge.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00374 A2D_EVT_MENU( CmdMenu_ChangeCanvasObjectStyle.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00375 A2D_EVT_MENU( CmdMenu_ChangeCentralStyle.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00376
00377 A2D_EVT_MENU( CmdMenu_SetLayer.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00378 A2D_EVT_MENU( CmdMenu_SetTarget.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00379 A2D_EVT_MENU( CmdMenu_SetDrawWireFrame.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00380 A2D_EVT_MENU( CmdMenu_DrawGridLines.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00381 A2D_EVT_MENU( CmdMenu_DrawGridAtFront.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00382 A2D_EVT_MENU( CmdMenu_DrawGrid.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00383 A2D_EVT_MENU( CmdMenu_SetSnap.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00384 A2D_EVT_MENU( CmdMenu_SetYAxis.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00385 A2D_EVT_MENU( CmdMenu_Option_SplinePoly.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00386 A2D_EVT_MENU( CmdMenu_Option_CursorCrosshair.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00387 A2D_EVT_MENU( CmdMenu_Option_RescaleAtReSize.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00388 A2D_EVT_MENU( CmdMenu_Option_ReverseLayers.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00389
00390 A2D_EVT_MENU( CmdMenu_SetSnapFeatures.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00391 A2D_EVT_MENU( CmdMenu_SetSnapFeature.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00392 A2D_EVT_MENU( CmdMenu_SetStroke.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00393 A2D_EVT_MENU( CmdMenu_SetFill.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00394 A2D_EVT_MENU( CmdMenu_SetStrokeColour.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00395 A2D_EVT_MENU( CmdMenu_SetFillColour.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00396 A2D_EVT_MENU( CmdMenu_SetContourWidth.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00397 A2D_EVT_MENU( CmdMenu_SetPathType.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00398 A2D_EVT_MENU( CmdMenu_SetNormalizeFactor.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00399
00400 A2D_EVT_MENU( CmdMenu_Refresh.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00401 A2D_EVT_MENU( CmdMenu_ZoomOut.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00402 A2D_EVT_MENU( CmdMenu_ZoomOut2.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00403 A2D_EVT_MENU( CmdMenu_ZoomIn2.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00404 A2D_EVT_MENU( CmdMenu_EmptyShownObject.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00405 A2D_EVT_MENU( CmdMenu_GdsIoSaveTextAsPolygon.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00406 A2D_EVT_MENU( CmdMenu_KeyIoSaveTextAsPolygon.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00407 A2D_EVT_MENU( CmdMenu_SetGdsIoSaveFromView.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00408 A2D_EVT_MENU( CmdMenu_SetKeyIoSaveFromView.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00409
00410 A2D_EVT_MENU( CmdMenu_PushInto.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00411 A2D_EVT_MENU( CmdMenu_NewGroup.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00412 A2D_EVT_MENU( CmdMenu_NewPin.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00413 A2D_EVT_MENU( CmdMenu_SaveLayers.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00414 A2D_EVT_MENU( CmdMenu_SaveLayersHome.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00415 A2D_EVT_MENU( CmdMenu_SaveLayersLastDir.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00416 A2D_EVT_MENU( CmdMenu_SaveLayersCurrentDir.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00417 A2D_EVT_MENU( CmdMenu_LoadLayers.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00418 A2D_EVT_MENU( CmdMenu_LoadLayersHome.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00419 A2D_EVT_MENU( CmdMenu_LoadLayersLastDir.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00420 A2D_EVT_MENU( CmdMenu_LoadLayersCurrentDir.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00421
00422 A2D_EVT_MENU( CmdMenu_SetCursor.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00423 A2D_EVT_MENU( CmdMenu_SetRelativeStart.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00424 A2D_EVT_MENU( CmdMenu_AddMeasurement.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00425 A2D_EVT_MENU( CmdMenu_ClearMeasurements.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00426
00427 A2D_EVT_MENU( CmdMenu_GdsIoSaveFromView.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00428 A2D_EVT_MENU( CmdMenu_KeyIoSaveFromView.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00429 A2D_EVT_MENU( CmdMenu_SetLayersProperty.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00430
00431 A2D_EVT_MENU( CmdMenu_Selected_SelectAll.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00432 A2D_EVT_MENU( CmdMenu_Selected_DeSelectAll.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00433 A2D_EVT_MENU( CmdMenu_Selected_Delete.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00434 A2D_EVT_MENU( CmdMenu_Selected_Group.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00435 A2D_EVT_MENU( CmdMenu_Selected_ImageToRectangles.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00436 A2D_EVT_MENU( CmdMenu_Selected_ToTop.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00437 A2D_EVT_MENU( CmdMenu_Selected_ToBack.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00438 A2D_EVT_MENU( CmdMenu_Selected_SetStyle.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00439 A2D_EVT_MENU( CmdMenu_Selected_ConvertToPolygonPolylinesWithArcs.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00440 A2D_EVT_MENU( CmdMenu_Selected_ConvertToPolygonPolylinesWithoutArcs.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00441 A2D_EVT_MENU( CmdMenu_Selected_ConvertToPolylines.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00442 A2D_EVT_MENU( CmdMenu_Selected_ConvertLinesArcs.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00443 A2D_EVT_MENU( CmdMenu_Selected_ConvertToVPaths.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00444 A2D_EVT_MENU( CmdMenu_Selected_ConvertPolygonToArcs.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00445 A2D_EVT_MENU( CmdMenu_Selected_ConvertPolylineToArcs.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00446 A2D_EVT_MENU( CmdMenu_Selected_ConvertPathToPolygon.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00447 A2D_EVT_MENU( CmdMenu_Selected_ConvertPolygonToSurface.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00448 A2D_EVT_MENU( CmdMenu_Selected_ConvertSurfaceToPolygon.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00449 A2D_EVT_MENU( CmdMenu_Selected_UnGroup.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00450 A2D_EVT_MENU( CmdMenu_Selected_UnGroupDeep.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00451 A2D_EVT_MENU( CmdMenu_Selected_Merge.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00452 A2D_EVT_MENU( CmdMenu_Selected_Offset.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00453 A2D_EVT_MENU( CmdMenu_Selected_CreateRing.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00454
00455 A2D_EVT_MENU( CmdMenu_GroupAB_Offset.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00456 A2D_EVT_MENU( CmdMenu_GroupAB_Smooth.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00457 A2D_EVT_MENU( CmdMenu_GroupAB_CreateRing.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00458 A2D_EVT_MENU( CmdMenu_GroupAB_Delete.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00459 A2D_EVT_MENU( CmdMenu_GroupAB_Move.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00460 A2D_EVT_MENU( CmdMenu_GroupAB_Copy.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00461 A2D_EVT_MENU( CmdMenu_GroupAB_ToArcs.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00462 A2D_EVT_MENU( CmdMenu_GroupAB_Or.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00463 A2D_EVT_MENU( CmdMenu_GroupAB_And.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00464 A2D_EVT_MENU( CmdMenu_GroupAB_Exor.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00465 A2D_EVT_MENU( CmdMenu_GroupAB_AsubB.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00466 A2D_EVT_MENU( CmdMenu_GroupAB_BsubA.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00467 A2D_EVT_MENU( CmdMenu_GroupAB_ConvertPolygonToSurface.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00468 A2D_EVT_MENU( CmdMenu_GroupAB_ConvertSurfaceToPolygon.GetId(), a2dCentralCanvasCommandProcessor::OnMenu )
00469 A2D_EVT_UPDATE_UI( CmdMenu_GdsIoSaveTextAsPolygon.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00470 A2D_EVT_UPDATE_UI( CmdMenu_KeyIoSaveTextAsPolygon.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00471 A2D_EVT_UPDATE_UI( CmdMenu_SetGdsIoSaveFromView.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00472 A2D_EVT_UPDATE_UI( CmdMenu_SetKeyIoSaveFromView.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00473 A2D_EVT_UPDATE_UI( CmdMenu_SetDrawWireFrame.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00474 A2D_EVT_UPDATE_UI( CmdMenu_DrawGridLines.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00475 A2D_EVT_UPDATE_UI( CmdMenu_DrawGridAtFront.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00476 A2D_EVT_UPDATE_UI( CmdMenu_DrawGrid.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00477 A2D_EVT_UPDATE_UI( CmdMenu_SetSnap.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00478 A2D_EVT_UPDATE_UI( CmdMenu_SetYAxis.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00479 A2D_EVT_UPDATE_UI( CmdMenu_Option_SplinePoly.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00480 A2D_EVT_UPDATE_UI( CmdMenu_Option_CursorCrosshair.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00481 A2D_EVT_UPDATE_UI( CmdMenu_Option_RescaleAtReSize.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00482 A2D_EVT_UPDATE_UI( CmdMenu_Option_ReverseLayers.GetId(), a2dCentralCanvasCommandProcessor::OnUpdateMenu )
00483
00484 A2D_END_EVENT_TABLE()
00485
00486 a2dCentralCanvasCommandProcessor::a2dCentralCanvasCommandProcessor( long flags , bool initialize, int maxCommands )
00487 : a2dDocumentCommandProcessor( flags, initialize, maxCommands )
00488 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
00489 , m_initCurrentSmartPointerOwner(this)
00490 #endif
00491 {
00492 m_popBeforePush = true;
00493 m_oneShotTools = false;
00494 m_editAtEndTools = true;
00495
00496 if ( CheckCanvasDocument() )
00497 m_parent = CheckCanvasDocument()->GetRootObject();
00498
00499 m_currentobject = 0;
00500 m_currentfill = a2dFill(wxColour(0,149,25 ),a2dFILL_HORIZONTAL_HATCH);
00501 m_currentstroke = a2dStroke( wxColour(0,255,0), 0, a2dSTROKE_SOLID );
00502
00503 m_currentEnd = 0;
00504 m_currentBegin = 0;
00505 m_currentXscale = m_currentYscale = 1;
00506
00507 m_AppendOrPrepend = true;
00508
00509 m_layer = wxLAYER_DEFAULT;
00510 m_target = wxLAYER_DEFAULT;
00511 m_selectedOnlyA = false;
00512 m_selectedOnlyB = false;
00513 m_clearTarget = false;
00514 m_CORRECTIONFACTOR = 500.0e-6;
00515 m_CORRECTIONABER = 1.0e-6;
00516 m_ROUNDFACTOR = 1.5;
00517 m_SMOOTHABER = 0.001e-6;
00518 m_MAXLINEMERGE = 1000.0e-6;
00519 m_MARGE = 0.1e-6;
00520 m_GRID =100;
00521 m_DGRID = 100;
00522 m_radiusMin = a2dCanvasGlobals->POLYTOARCRMIN();
00523 m_radiusMax = a2dCanvasGlobals->POLYTOARCRMAX();
00524 m_AberPolyToArc = a2dCanvasGlobals->POLYTOARCABER();
00525 m_AberArcToPoly = a2dCanvasGlobals->ARCTOPOLYABER();
00526
00527 m_WINDINGRULE = true;
00528 m_SmoothAber = 0.1e-6;
00529 m_LinkHoles = false;
00530 m_currentContourWidth = 0.0e-6;
00531 m_pathtype = a2dPATH_END_SQAURE;
00532
00533 m_font = *a2dDEFAULT_CANVASFONT;
00534
00535 m_spline = false;
00536 m_lastX = m_lastY = 0;
00537 m_keySaveTextAsPolygon = false;
00538 m_gdsiiSaveTextAsPolygon = false;
00539 m_keySaveFromView = false;
00540 m_gdsiiSaveFromView = false;
00541 }
00542
00543 a2dCentralCanvasCommandProcessor::a2dCentralCanvasCommandProcessor( a2dDocumentCommandProcessor* other )
00544 : a2dDocumentCommandProcessor( other )
00545 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
00546 , m_initCurrentSmartPointerOwner(this)
00547 #endif
00548 {
00549 m_popBeforePush = true;
00550 m_oneShotTools = false;
00551 m_editAtEndTools = true;
00552
00553 if ( CheckCanvasDocument() )
00554 m_parent = CheckCanvasDocument()->GetRootObject();
00555
00556 m_currentobject = 0;
00557 m_currentfill = a2dFill(wxColour(0,149,25 ),a2dFILL_HORIZONTAL_HATCH);
00558 m_currentstroke = a2dStroke( wxColour(0,255,0), 0, a2dSTROKE_SOLID );
00559
00560 m_currentEnd = 0;
00561 m_currentBegin = 0;
00562 m_currentXscale = m_currentYscale = 1;
00563
00564 m_AppendOrPrepend = true;
00565
00566 m_layer = wxLAYER_DEFAULT;
00567 m_target = wxLAYER_DEFAULT;
00568
00569 m_font = *a2dDEFAULT_CANVASFONT;
00570
00571 m_spline = false;
00572 }
00573
00574 a2dCentralCanvasCommandProcessor::~a2dCentralCanvasCommandProcessor()
00575 {
00576 }
00577
00578 void a2dCentralCanvasCommandProcessor::OnUpdateMenu(wxUpdateUIEvent& event)
00579 {
00580 if ( event.GetId() == CmdMenu_GdsIoSaveTextAsPolygon.GetId() )
00581 event.Check( m_gdsiiSaveTextAsPolygon );
00582 else if ( event.GetId() == CmdMenu_KeyIoSaveTextAsPolygon.GetId() )
00583 event.Check( m_keySaveTextAsPolygon );
00584 else if ( event.GetId() == CmdMenu_SetGdsIoSaveFromView.GetId() )
00585 event.Check( m_gdsiiSaveFromView );
00586 else if ( event.GetId() == CmdMenu_SetKeyIoSaveFromView.GetId() )
00587 event.Check( m_keySaveFromView );
00588 else if ( event.GetId() == CmdMenu_SetDrawWireFrame.GetId() )
00589 {
00590 a2dCanvasView* drawer = CheckDrawer();
00591 if ( !drawer )
00592 return;
00593 if ( (RenderWIREFRAME_ZERO_WIDTH | RenderWIREFRAME_SELECT) == drawer->GetDocumentDrawStyle() )
00594 event.Check( true );
00595 else
00596 event.Check( false );
00597 }
00598 else if ( event.GetId() == CmdMenu_DrawGridLines.GetId() )
00599 {
00600 a2dCanvasView* drawer = CheckDrawer();
00601 if ( drawer )
00602 event.Check( drawer->GetGridLines() );
00603 }
00604 else if ( event.GetId() == CmdMenu_DrawGridAtFront.GetId() )
00605 {
00606 a2dCanvasView* drawer = CheckDrawer();
00607 if ( drawer )
00608 event.Check( drawer->GetGridAtFront() );
00609 }
00610 else if ( event.GetId() == CmdMenu_DrawGrid.GetId() )
00611 {
00612 a2dCanvasView* drawer = CheckDrawer();
00613 if ( drawer )
00614 event.Check( drawer->GetGrid() );
00615 }
00616 else if ( event.GetId() == CmdMenu_SetSnap.GetId() )
00617 {
00618 a2dCanvasView* drawer = CheckDrawer();
00619 if ( drawer )
00620 event.Check( drawer->GetCanvasToolContr()->GetSnap() );
00621 }
00622 else if ( event.GetId() == CmdMenu_SetYAxis.GetId() )
00623 {
00624 a2dCanvasView* drawer = CheckDrawer();
00625 if ( drawer )
00626 event.Check( drawer->GetDrawer2D()->GetYaxis() );
00627 }
00628 else if ( event.GetId() == CmdMenu_Option_SplinePoly.GetId() )
00629 {
00630 event.Check( GetSpline() );
00631 }
00632 else if ( event.GetId() == CmdMenu_Option_CursorCrosshair.GetId() )
00633 {
00634 a2dCanvasView* drawer = CheckDrawer();
00635 if ( drawer )
00636 event.Check( drawer->GetCrossHair() );
00637 }
00638 else if ( event.GetId() == CmdMenu_Option_RescaleAtReSize.GetId() )
00639 {
00640 a2dCanvasView* drawer = CheckDrawer();
00641 if ( drawer )
00642 event.Check( drawer->GetCanvas()->GetScaleOnResize() );
00643 }
00644 else if ( event.GetId() == CmdMenu_Option_ReverseLayers.GetId() )
00645 {
00646 a2dCanvasView* drawer = CheckDrawer();
00647 if ( drawer )
00648 event.Check( drawer->GetReverseOrder() );
00649 }
00650 else
00651 event.Skip();
00652 }
00653
00654
00655 void a2dCentralCanvasCommandProcessor::OnMenu( wxCommandEvent& event )
00656 {
00657 bool found = false;
00658 if ( event.GetId() == CmdMenu_ChangeCanvasObjectStyle.GetId() )
00659 {
00660 found = true;
00661 }
00662 else if ( event.GetId() == CmdMenu_ChangeCentralStyle.GetId() )
00663 {
00664 found = true;
00665 }
00666 else if ( event.GetId() == CmdMenu_SetLayer.GetId() )
00667 {
00668 found = true;
00669 long w = wxGetNumberFromUser(_("Give layer number:"), _("Layer:"), _("layer number"), m_layer,0, wxMAXLAYER );
00670
00671 if ( w != -1 )
00672 {
00673 if ( w >= 0 && w < (long) wxMAXLAYER )
00674 {
00675 Submit( new a2dCommand_SetLayer( w ), true );
00676 }
00677 else
00678 (void)wxMessageBox(_("Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
00679 }
00680 }
00681 else if ( event.GetId() == CmdMenu_SetTarget.GetId() )
00682 {
00683 found = true;
00684 long w = wxGetNumberFromUser(_("Give layer number:"), _("Layer:"), _("Set Target Layer"), m_target,0, wxMAXLAYER );
00685
00686 if ( w != -1 )
00687 {
00688 if ( w >= 0 && w < (long) wxMAXLAYER )
00689 {
00690 Submit( new a2dCommand_SetTarget( w ), true );
00691 }
00692 else
00693 (void)wxMessageBox(_("Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
00694 }
00695 }
00696 else if ( event.GetId() == CmdMenu_SetDrawWireFrame.GetId() )
00697 {
00698 found = true;
00699 a2dCanvasView* drawer = CheckDrawer();
00700 if ( !drawer )
00701 return;
00702 if ( (RenderWIREFRAME_ZERO_WIDTH | RenderWIREFRAME_SELECT) == drawer->GetDocumentDrawStyle() )
00703 Submit( new a2dCommand_SetDrawWireFrame( RenderLAYERED | RenderWIREFRAME_SELECT ));
00704 else
00705 Submit( new a2dCommand_SetDrawWireFrame( RenderWIREFRAME_ZERO_WIDTH | RenderWIREFRAME_SELECT ));
00706 }
00707 else if ( event.GetId() == CmdMenu_DrawGridLines.GetId() )
00708 {
00709 found = true;
00710 a2dCanvasView* drawer = CheckDrawer();
00711 if ( drawer )
00712 drawer->SetGridLines( !drawer->GetGridLines() );
00713
00714 }
00715 else if ( event.GetId() == CmdMenu_DrawGridAtFront.GetId() )
00716 {
00717 found = true;
00718 a2dCanvasView* drawer = CheckDrawer();
00719 if ( drawer )
00720 drawer->SetGridAtFront( !drawer->GetGridAtFront() );
00721
00722 }
00723 else if ( event.GetId() == CmdMenu_Refresh.GetId() )
00724 {
00725 found = true;
00726 Submit( new a2dCommand_Refresh() );
00727 }
00728 else if ( event.GetId() == CmdMenu_ZoomOut.GetId() )
00729 {
00730 found = true;
00731 a2dCanvasView* drawer = CheckDrawer();
00732 if ( drawer )
00733 drawer->SetMappingShowAll();
00734 }
00735 else if ( event.GetId() == CmdMenu_ZoomOut2.GetId() )
00736 {
00737 found = true;
00738 a2dCanvasView* drawer = CheckDrawer();
00739 if ( !drawer )
00740 return;
00741 if ( !drawer->GetDisplayWindow() )
00742 return;
00743 a2dDrawer2D* dr = drawer->GetDrawer2D();
00744 if ( !dr )
00745 return;
00746
00747 int dx,dy;
00748 drawer->GetDisplayWindow()->GetClientSize(&dx,&dy);
00749 if (dy > dx) dx=dy;
00750
00751 dr->SetMappingUpp(
00752 dr->GetVisibleMinX() - dr->GetUppX()*dx/2,
00753 dr->GetVisibleMinY() - dr->GetUppY()*dy/2,
00754 dr->GetUppX()*2, dr->GetUppY()*2);
00755 }
00756 else if ( event.GetId() == CmdMenu_ZoomIn2.GetId() )
00757 {
00758 found = true;
00759 a2dCanvasView* drawer = CheckDrawer();
00760 if ( !drawer )
00761 return;
00762 if ( !drawer->GetDisplayWindow() )
00763 return;
00764 a2dDrawer2D* dr = drawer->GetDrawer2D();
00765 if ( !dr )
00766 return;
00767
00768 int dx,dy;
00769 drawer->GetDisplayWindow()->GetClientSize(&dx,&dy);
00770 if (dy > dx) dx=dy;
00771
00772 dr->SetMappingUpp(
00773 dr->GetVisibleMinX() + dr->GetUppX()*dx/4,
00774 dr->GetVisibleMinY() + dr->GetUppY()*dy/4,
00775 dr->GetUppX()*0.5, dr->GetUppY()*0.5);
00776 }
00777 else if ( event.GetId() == CmdMenu_EmptyShownObject.GetId() )
00778 {
00779 found = true;
00780 a2dCanvasView* drawer = CheckDrawer();
00781 if ( !drawer )
00782 return;
00783
00784 if ( ! drawer->GetShowObject() )
00785 return;
00786
00787 drawer->GetShowObject()->ReleaseChildObjects();
00788 }
00789 else if ( event.GetId() == CmdMenu_DrawGrid.GetId() )
00790 {
00791 found = true;
00792 a2dCanvasView* drawer = CheckDrawer();
00793 if ( drawer )
00794 drawer->SetGrid( !drawer->GetGrid() );
00795
00796 }
00797 else if ( event.GetId() == CmdMenu_SetSnap.GetId() )
00798 {
00799 found = true;
00800 a2dCanvasView* drawer = CheckDrawer();
00801 if ( !drawer )
00802 return;
00803 Submit( new a2dCommand_SetSnap( !drawer->GetCanvasToolContr()->GetSnap() ) );
00804 }
00805 else if ( event.GetId() == CmdMenu_SetYAxis.GetId() )
00806 {
00807 found = true;
00808 a2dCanvasView* drawer = CheckDrawer();
00809 if ( !drawer )
00810 return;
00811 if ( !drawer->GetDrawer2D() )
00812 return;
00813 drawer->GetDrawer2D()->SetYaxis( !drawer->GetDrawer2D()->GetYaxis() );
00814 drawer->SetMappingShowAll();
00815 }
00816 else if ( event.GetId() == CmdMenu_Option_SplinePoly.GetId() )
00817 {
00818 found = true;
00819 SetSpline( !GetSpline() );
00820 }
00821 else if ( event.GetId() == CmdMenu_Option_CursorCrosshair.GetId() )
00822 {
00823 found = true;
00824 a2dCanvasView* drawer = CheckDrawer();
00825 if ( !drawer )
00826 return;
00827 if ( !drawer->GetDrawer2D() )
00828 return;
00829 drawer->SetCrossHair( !drawer->GetCrossHair() );
00830 }
00831 else if ( event.GetId() == CmdMenu_Option_RescaleAtReSize.GetId() )
00832 {
00833 found = true;
00834 a2dCanvasView* drawer = CheckDrawer();
00835 if ( !drawer )
00836 return;
00837 if ( !drawer->GetCanvas() )
00838 return;
00839 drawer->GetCanvas()->SetScaleOnResize( !drawer->GetCanvas()->GetScaleOnResize() );
00840 }
00841 else if ( event.GetId() == CmdMenu_Option_ReverseLayers.GetId() )
00842 {
00843 found = true;
00844 a2dCanvasView* drawer = CheckDrawer();
00845 if ( !drawer )
00846 return;
00847 if ( !drawer->GetDrawer2D() )
00848 return;
00849 drawer->SetReverseOrder(!drawer->GetReverseOrder());
00850 }
00851 else if ( event.GetId() == CmdMenu_SetSnapFeatures.GetId() )
00852 {
00853 found = true;
00854 }
00855 else if ( event.GetId() == CmdMenu_SetSnapFeature.GetId() )
00856 {
00857 found = true;
00858 }
00859 else if ( event.GetId() == CmdMenu_SetStroke.GetId() )
00860 {
00861 found = true;
00862 }
00863 else if ( event.GetId() == CmdMenu_SetFill.GetId() )
00864 {
00865 found = true;
00866 }
00867 else if ( event.GetId() == CmdMenu_SetStrokeColour.GetId() )
00868 {
00869 found = true;
00870 }
00871 else if ( event.GetId() == CmdMenu_SetFillColour.GetId() )
00872 {
00873 found = true;
00874 }
00875 else if ( event.GetId() == CmdMenu_SetContourWidth.GetId() )
00876 {
00877 found = true;
00878 }
00879 else if ( event.GetId() == CmdMenu_SetPathType.GetId() )
00880 {
00881 found = true;
00882 }
00883 else if ( event.GetId() == CmdMenu_SetNormalizeFactor.GetId() )
00884 {
00885 found = true;
00886 if ( !CheckCanvasDocument() )
00887 return;
00888
00889 double norm = wxGetDoubleNumberFromUser(_("Give normalize factor:"), _("Normalize"), _("Normalize factor"), 1, 0, 10000 );
00890
00891 if ( norm != -1 )
00892 {
00893 if ( norm >= 0 && norm < 10000 )
00894 {
00895 CheckCanvasDocument()->SetNormalizeScale( norm );
00896
00897 }
00898 else
00899 (void)wxMessageBox(_("Normlaize factor must be > 0"), _("Normalize"), wxICON_INFORMATION | wxOK );
00900 }
00901 }
00902 else if ( event.GetId() == CmdMenu_Refresh.GetId() )
00903 {
00904 found = true;
00905 Submit( new a2dCommand_Refresh() );
00906 }
00907 else if ( event.GetId() == CmdMenu_GdsIoSaveTextAsPolygon.GetId() )
00908 {
00909 found = true;
00910 GdsIoSaveTextAsPolygon( !m_gdsiiSaveTextAsPolygon );
00911 }
00912 else if ( event.GetId() == CmdMenu_KeyIoSaveTextAsPolygon.GetId() )
00913 {
00914 found = true;
00915 KeyIoSaveTextAsPolygon( !m_keySaveTextAsPolygon );
00916 }
00917 else if ( event.GetId() == CmdMenu_SetGdsIoSaveFromView.GetId() )
00918 {
00919 found = true;
00920 m_gdsiiSaveFromView = !m_gdsiiSaveFromView;
00921 a2dCommand_GdsIoSaveFromView* command = new a2dCommand_GdsIoSaveFromView( m_gdsiiSaveFromView );
00922 Submit( command );
00923 }
00924 else if ( event.GetId() == CmdMenu_SetKeyIoSaveFromView.GetId() )
00925 {
00926 found = true;
00927 m_keySaveFromView = !m_keySaveFromView;
00928 a2dCommand_KeyIoSaveFromView* command = new a2dCommand_KeyIoSaveFromView( m_keySaveFromView );
00929 Submit( command );
00930 }
00931
00932 if ( found )
00933 {}
00934 else if ( event.GetId() == CmdMenu_PushInto.GetId() )
00935 {
00936 found = true;
00937 a2dCommand_PushInto* command = new a2dCommand_PushInto( a2dCommand_PushInto::Args().selected(true));
00938 SubmitToDocument( command );
00939 }
00940 else if ( event.GetId() == CmdMenu_NewGroup.GetId() )
00941 {
00942 found = true;
00943 SubmitToDocument( new a2dCommand_NewGroup( a2dCommand_NewGroup::Args() ) );
00944 }
00945 else if ( event.GetId() == CmdMenu_NewPin.GetId() )
00946 {
00947 found = true;
00948 SubmitToDocument( new a2dCommand_NewPin( a2dCommand_NewPin::Args() ) );
00949 }
00950 else if ( event.GetId() == CmdMenu_SaveLayers.GetId() )
00951 {
00952 found = true;
00953 a2dCommandGroup* gr = new a2dCommandGroup( _T("saveLayers") );
00954 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
00955 message( _("Give Name of output Layer file") ).
00956 defaultDir( _T("@{layerFileApplication}") ).
00957 extension( _T("*.cvg") ).
00958 fileFilter( _T("*.cvg") ).
00959 flags( wxFD_SAVE | wxFD_OVERWRITE_PROMPT ).
00960 storeInVariable( _T("ask_file_result") ) );
00961 gr->Add( command );
00962 a2dCommand_SaveLayers* command2 = new a2dCommand_SaveLayers( wxFileName( _T("%{ask_file_result}") ) );
00963 gr->Add( command2 );
00964 Submit( gr );
00965 }
00966 else if ( event.GetId() == CmdMenu_SaveLayersLastDir.GetId() )
00967 {
00968 found = true;
00969 a2dCommandGroup* gr = new a2dCommandGroup( _T("saveLayers") );
00970 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
00971 message( _("Give Name of output Layer file") ).
00972 defaultDir( _T("@{lastLayerFileSavePath}") ).
00973 extension( _T("*.cvg") ).
00974 fileFilter( _T("*.cvg") ).
00975 flags( wxFD_SAVE | wxFD_OVERWRITE_PROMPT ).
00976 storeInVariable( _T("ask_file_result") ) );
00977 gr->Add( command );
00978 a2dCommand_SaveLayers* command2 = new a2dCommand_SaveLayers( wxFileName( _T("%{ask_file_result}") ) );
00979 gr->Add( command2 );
00980 Submit( gr );
00981 }
00982 else if ( event.GetId() == CmdMenu_SaveLayersHome.GetId() )
00983 {
00984 found = true;
00985 a2dCommandGroup* gr = new a2dCommandGroup( _T("saveLayers") );
00986 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
00987 message( _("Give Name of output Layer file") ).
00988 defaultDir( _T("@{layerFileSavePath}") ).
00989 extension( _T("*.cvg") ).
00990 fileFilter( _T("*.cvg") ).
00991 flags( wxFD_SAVE | wxFD_OVERWRITE_PROMPT ).
00992 storeInVariable( _T("ask_file_result") ) );
00993 gr->Add( command );
00994 a2dCommand_SaveLayers* command2 = new a2dCommand_SaveLayers( wxFileName( _T("%{ask_file_result}") ) );
00995 gr->Add( command2 );
00996 Submit( gr );
00997 }
00998 else if ( event.GetId() == CmdMenu_SaveLayersCurrentDir.GetId() )
00999 {
01000 found = true;
01001 a2dCommandGroup* gr = new a2dCommandGroup( _T("saveLayers") );
01002 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
01003 message( _("Give Name of output Layer file") ).
01004 defaultDir( _T("./") ).
01005 extension( _T("*.cvg") ).
01006 fileFilter( _T("*.cvg") ).
01007 flags( wxFD_SAVE | wxFD_OVERWRITE_PROMPT ).
01008 storeInVariable( _T("ask_file_result") ) );
01009 gr->Add( command );
01010 a2dCommand_SaveLayers* command2 = new a2dCommand_SaveLayers( wxFileName( _T("%{ask_file_result}") ) );
01011 gr->Add( command2 );
01012 Submit( gr );
01013 }
01014 else if ( event.GetId() == CmdMenu_LoadLayers.GetId() )
01015 {
01016 found = true;
01017 a2dCommandGroup* gr = new a2dCommandGroup( _T("loadLayers") );
01018 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
01019 message( _("Give Name of input Layer file") ).
01020 defaultDir( _T("@{layerFileApplication}") ).
01021 extension( _T("*.cvg") ).
01022 fileFilter( _T("*.cvg") ).
01023 flags( wxFD_OPEN | wxFD_FILE_MUST_EXIST ).
01024 storeInVariable( _T("ask_file_result") ) );
01025 gr->Add( command );
01026 a2dCommand_LoadLayers* command2 = new a2dCommand_LoadLayers( wxFileName( _T("%{ask_file_result}") ) );
01027 gr->Add( command2 );
01028 Submit( gr );
01029 }
01030 else if ( event.GetId() == CmdMenu_LoadLayersHome.GetId() )
01031 {
01032 found = true;
01033 a2dCommandGroup* gr = new a2dCommandGroup( _T("loadLayers") );
01034 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
01035 message( _("Give Name of input Layer file") ).
01036 defaultDir( _T("@{layerFileSavePath}") ).
01037 extension( _T("*.cvg") ).
01038 fileFilter( _T("*.cvg") ).
01039 flags( wxFD_OPEN | wxFD_FILE_MUST_EXIST ).
01040 storeInVariable( _T("ask_file_result") ) );
01041 gr->Add( command );
01042 a2dCommand_LoadLayers* command2 = new a2dCommand_LoadLayers( wxFileName( _T("%{ask_file_result}") ) );
01043 gr->Add( command2 );
01044 Submit( gr );
01045 }
01046 else if ( event.GetId() == CmdMenu_LoadLayersLastDir.GetId() )
01047 {
01048 found = true;
01049 a2dCommandGroup* gr = new a2dCommandGroup( _T("loadLayers") );
01050 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
01051 message( _("Give Name of input Layer file") ).
01052 defaultDir( _T("@{lastLayerFileSavePath}") ).
01053 extension( _T("*.cvg") ).
01054 fileFilter( _T("*.cvg") ).
01055 flags( wxFD_OPEN | wxFD_FILE_MUST_EXIST ).
01056 storeInVariable( _T("ask_file_result") ) );
01057 gr->Add( command );
01058 a2dCommand_LoadLayers* command2 = new a2dCommand_LoadLayers( wxFileName( _T("%{ask_file_result}") ) );
01059 gr->Add( command2 );
01060 Submit( gr );
01061 }
01062 else if ( event.GetId() == CmdMenu_LoadLayersCurrentDir.GetId() )
01063 {
01064 found = true;
01065 a2dCommandGroup* gr = new a2dCommandGroup( _T("loadLayers") );
01066 a2dCommand_AskFile* command = new a2dCommand_AskFile( a2dCommand_AskFile::Args().
01067 message( _("Give Name of input Layer file") ).
01068 defaultDir( _T("./") ).
01069 extension( _T("*.cvg") ).
01070 fileFilter( _T("*.cvg") ).
01071 flags( wxFD_OPEN | wxFD_FILE_MUST_EXIST ).
01072 storeInVariable( _T("ask_file_result") ) );
01073 gr->Add( command );
01074 a2dCommand_LoadLayers* command2 = new a2dCommand_LoadLayers( wxFileName( _T("%{ask_file_result}") ) );
01075 gr->Add( command2 );
01076 Submit( gr );
01077 }
01078 else if ( event.GetId() == CmdMenu_SetCursor.GetId() )
01079 {
01080 found = true;
01081 }
01082 else if ( event.GetId() == CmdMenu_SetRelativeStart.GetId() )
01083 {
01084 found = true;
01085 }
01086 else if ( event.GetId() == CmdMenu_AddMeasurement.GetId() )
01087 {
01088 found = true;
01089 }
01090 else if ( event.GetId() == CmdMenu_ClearMeasurements.GetId() )
01091 {
01092 found = true;
01093 }
01094 else if ( event.GetId() == CmdMenu_GdsIoSaveFromView.GetId() )
01095 {
01096 found = true;
01097 m_gdsiiSaveFromView = !m_gdsiiSaveFromView;
01098 a2dCommand_GdsIoSaveFromView* command = new a2dCommand_GdsIoSaveFromView( m_gdsiiSaveFromView );
01099 Submit( command );
01100 }
01101 else if ( event.GetId() == CmdMenu_KeyIoSaveFromView.GetId() )
01102 {
01103 found = true;
01104 m_keySaveFromView = !m_keySaveFromView;
01105 a2dCommand_KeyIoSaveFromView* command = new a2dCommand_KeyIoSaveFromView( m_keySaveFromView );
01106 Submit( command );
01107 }
01108 else if ( event.GetId() == CmdMenu_SetLayersProperty.GetId() )
01109 {
01110 found = true;
01111 }
01112 else if ( event.GetId() == CmdMenu_Selected_SelectAll.GetId() )
01113 {
01114 found = true;
01115 SubmitToDocument( new a2dCommand_Select( a2dCommand_Select::Args().what(a2dCommand_Select::SelectAll) ) );
01116 }
01117 else if ( event.GetId() == CmdMenu_Selected_DeSelectAll.GetId() )
01118 {
01119 found = true;
01120 SubmitToDocument( new a2dCommand_Select( a2dCommand_Select::Args().what(a2dCommand_Select::DeSelectAll) ) );
01121 }
01122 else if ( event.GetId() == CmdMenu_Selected_Delete.GetId() )
01123 {
01124 found = true;
01125 SubmitToDocument( new a2dCommand_DeleteMask() );
01126 }
01127 else if ( event.GetId() == CmdMenu_Selected_Group.GetId() )
01128 {
01129 found = true;
01130 SubmitToDocument( new a2dCommand_GroupMask( wxT("") ) );
01131 }
01132 else if ( event.GetId() == CmdMenu_Selected_ImageToRectangles.GetId() )
01133 {
01134 found = true;
01135 SubmitToDocument( new a2dCommand_ImagesToRectMask() );
01136 }
01137 else if ( event.GetId() == CmdMenu_Selected_ToTop.GetId() )
01138 {
01139 found = true;
01140 SubmitToDocument( new a2dCommand_ToTopMask());
01141 }
01142 else if ( event.GetId() == CmdMenu_Selected_ToBack.GetId() )
01143 {
01144 found = true;
01145 SubmitToDocument( new a2dCommand_ToBackMask());
01146 }
01147 else if ( event.GetId() == CmdMenu_Selected_SetStyle.GetId() )
01148 {
01149 found = true;
01150 SubmitToDocument( new a2dCommand_SetFillStrokeMask());
01151 }
01152 else if ( event.GetId() == CmdMenu_Selected_ConvertToPolygonPolylinesWithArcs.GetId() )
01153 {
01154 found = true;
01155 SubmitToDocument( new a2dCommand_ConvertMask(a2dCommand_ConvertMask::ConvertToPolygonPolylinesWithArcs));
01156 }
01157 else if ( event.GetId() == CmdMenu_Selected_ConvertToPolygonPolylinesWithoutArcs.GetId() )
01158 {
01159 found = true;
01160 SubmitToDocument( new a2dCommand_ConvertMask(a2dCommand_ConvertMask::ConvertToPolygonPolylinesWithoutArcs));
01161 }
01162 else if ( event.GetId() == CmdMenu_Selected_ConvertToPolylines.GetId() )
01163 {
01164 found = true;
01165 SubmitToDocument( new a2dCommand_ConvertMask(a2dCommand_ConvertMask::ConvertToPolylines));
01166 }
01167 else if ( event.GetId() == CmdMenu_Selected_ConvertLinesArcs.GetId() )
01168 {
01169 found = true;
01170 SubmitToDocument( new a2dCommand_ConvertMask(a2dCommand_ConvertMask::ConvertLinesArcs));
01171 }
01172
01173 if ( found )
01174 {
01175 }
01176 else if ( event.GetId() == CmdMenu_Selected_ConvertToVPaths.GetId() )
01177 {
01178 found = true;
01179 SubmitToDocument( new a2dCommand_ConvertMask(a2dCommand_ConvertMask::ConvertToVPaths) );
01180 }
01181 else if ( event.GetId() == CmdMenu_Selected_ConvertPolygonToArcs.GetId() )
01182 {
01183 found = true;
01184 SubmitToDocument( new a2dCommand_ConvertMask(a2dCommand_ConvertMask::ConvertPolygonToArcs));
01185 }
01186 else if ( event.GetId() == CmdMenu_Selected_ConvertPolylineToArcs.GetId() )
01187 {
01188 found = true;
01189 SubmitToDocument( new a2dCommand_ConvertMask(a2dCommand_ConvertMask::ConvertPolylineToArcs));
01190 }
01191 else if ( event.GetId() == CmdMenu_Selected_ConvertPathToPolygon.GetId() )
01192 {
01193 found = true;
01194 }
01195 else if ( event.GetId() == CmdMenu_Selected_ConvertSurfaceToPolygon.GetId() )
01196 {
01197 found = true;
01198 SubmitToDocument( new a2dCommand_SurfaceToPolygonMask());
01199 }
01200 else if ( event.GetId() == CmdMenu_Selected_ConvertPolygonToSurface.GetId() )
01201 {
01202 found = true;
01203 SubmitToDocument( new a2dCommand_PolygonToSurfaceMask());
01204 }
01205 else if ( event.GetId() == CmdMenu_Selected_UnGroup.GetId() )
01206 {
01207 found = true;
01208 SubmitToDocument( new a2dCommand_UnGroupMask());
01209 }
01210 else if ( event.GetId() == CmdMenu_Selected_UnGroupDeep.GetId() )
01211 {
01212 found = true;
01213 a2dCommand_UnGroupMask* command = new a2dCommand_UnGroupMask( true );
01214 SubmitToDocument( command );
01215 }
01216 else if ( event.GetId() == CmdMenu_Selected_Merge.GetId() )
01217 {
01218 found = true;
01219 a2dCommand_MergeMask* command = new a2dCommand_MergeMask();
01220 SubmitToDocument( command );
01221 }
01222 else if ( event.GetId() == CmdMenu_Selected_Offset.GetId() )
01223 {
01224 found = true;
01225 a2dCommand_OffsetMask* command = new a2dCommand_OffsetMask();
01226 SubmitToDocument( command );
01227 }
01228 else if ( event.GetId() == CmdMenu_Selected_CreateRing.GetId() )
01229 {
01230 found = true;
01231 }
01232 else if ( event.GetId() == CmdMenu_GroupAB_Offset.GetId() )
01233 {
01234 found = true;
01235 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01236 what( a2dCommand_GroupAB::Boolean_CORRECTION ).
01237 selectedA( true ) );
01238 SubmitToDocument( command );
01239 }
01240 else if ( event.GetId() == CmdMenu_GroupAB_Smooth.GetId() )
01241 {
01242 found = true;
01243 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01244 what( a2dCommand_GroupAB::Boolean_SMOOTHEN ).
01245 selectedA( true ) );
01246 SubmitToDocument( command );
01247 }
01248 else if ( event.GetId() == CmdMenu_GroupAB_CreateRing.GetId() )
01249 {
01250 found = true;
01251 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01252 what( a2dCommand_GroupAB::Boolean_MAKERING ).
01253 selectedA( true ) );
01254 SubmitToDocument( command );
01255 }
01256 else if ( event.GetId() == CmdMenu_GroupAB_Delete.GetId() )
01257 {
01258 found = true;
01259 SubmitToDocument( new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().what( a2dCommand_GroupAB::DeleteGroupA ) ));
01260 }
01261 else if ( event.GetId() == CmdMenu_GroupAB_Move.GetId() )
01262 {
01263 found = true;
01264 SubmitToDocument( new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().what( a2dCommand_GroupAB::MoveGroupA ) ) );
01265 }
01266 else if ( event.GetId() == CmdMenu_GroupAB_Copy.GetId() )
01267 {
01268 found = true;
01269 SubmitToDocument( new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().what( a2dCommand_GroupAB::CopyGroupA ) ) );
01270 }
01271 else if ( event.GetId() == CmdMenu_GroupAB_ToArcs.GetId() )
01272 {
01273 found = true;
01274 SubmitToDocument( new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().what( a2dCommand_GroupAB::ConvertToArcs ) ) );
01275 }
01276 else if ( event.GetId() == CmdMenu_GroupAB_Or.GetId() )
01277 {
01278 found = true;
01279 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01280 what( a2dCommand_GroupAB::Boolean_OR ) );
01281 SubmitToDocument( command );
01282 }
01283 else if ( event.GetId() == CmdMenu_GroupAB_And.GetId() )
01284 {
01285 found = true;
01286 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01287 what( a2dCommand_GroupAB::Boolean_AND ) );
01288 SubmitToDocument( command );
01289 }
01290 else if ( event.GetId() == CmdMenu_GroupAB_Exor.GetId() )
01291 {
01292 found = true;
01293 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01294 what( a2dCommand_GroupAB::Boolean_EXOR ) );
01295 SubmitToDocument( command );
01296 }
01297 else if ( event.GetId() == CmdMenu_GroupAB_AsubB.GetId() )
01298 {
01299 found = true;
01300 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01301 what( a2dCommand_GroupAB::Boolean_A_SUB_B ) );
01302 SubmitToDocument( command );
01303 }
01304 else if ( event.GetId() == CmdMenu_GroupAB_BsubA.GetId() )
01305 {
01306 found = true;
01307 a2dCommand_GroupAB* command = new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().
01308 what( a2dCommand_GroupAB::Boolean_B_SUB_A ) );
01309 SubmitToDocument( command );
01310 }
01311 else if ( event.GetId() == CmdMenu_GroupAB_ConvertSurfaceToPolygon.GetId() )
01312 {
01313 found = true;
01314 SubmitToDocument( new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().what( a2dCommand_GroupAB::Boolean_Surface2Polygon) ));
01315 }
01316 else if ( event.GetId() == CmdMenu_GroupAB_ConvertPolygonToSurface.GetId() )
01317 {
01318 found = true;
01319 SubmitToDocument( new a2dCommand_GroupAB( a2dCommand_GroupAB::Args().what( a2dCommand_GroupAB::Boolean_Polygon2Surface) ));
01320 }
01321
01322 if ( !found )
01323 event.Skip();
01324 }
01325
01326 void a2dCentralCanvasCommandProcessor::FillLibraryPoints()
01327 {
01328 #if wxART2D_USE_CANEXTOBJ
01329
01330 m_librarypoints = new a2dCanvasDocument();
01331
01332
01333
01334 m_librarypoints->CreateCommandProcessor();
01335
01336 {
01337 a2dCircle* cire = new a2dCircle( 0,0, 1 );
01338 cire->SetFill(wxColour(219,215,6),a2dFILL_HORIZONTAL_HATCH );
01339 cire->SetStroke(wxColour(1,3,205 ),3.0);
01340 cire->SetSpecificFlags( true, a2dCanvasOFlags::normalized );
01341
01342 a2dLibraryReference* libobject = new a2dLibraryReference(0,0,cire,_T("circle"),100);
01343 libobject->SetStroke(wxColour(229,5,64 ),0);
01344 m_librarypoints->Append( libobject );
01345 }
01346
01347 {
01348 a2dArrow* arrow = new a2dArrow( 0,0,1,0.5, 0.5 );
01349 arrow->SetFill(wxColour(219,215,6));
01350 arrow->SetStroke(wxColour(1,3,205 ),1);
01351 arrow->SetSpecificFlags( true, a2dCanvasOFlags::normalized );
01352
01353 a2dLibraryReference* libobject = new a2dLibraryReference(0,-200,arrow,_T("arrow"),100);
01354 libobject->SetStroke(wxColour(229,5,64 ),0);
01355 m_librarypoints->Append( libobject );
01356 }
01357
01358 {
01359 a2dArrow* arrow2 = new a2dArrow( 0,0,2, 1, 2 );
01360 arrow2->SetFill(wxColour(219,2,6));
01361 arrow2->SetStroke(wxColour(255,3,205 ),1.0);
01362 arrow2->SetSpecificFlags( true, a2dCanvasOFlags::normalized );
01363
01364 a2dLibraryReference* libobject = new a2dLibraryReference( 0, -400, arrow2, _T("arrow2"), 100);
01365 libobject->SetStroke(wxColour(229,5,64 ),0);
01366 m_librarypoints->Append( libobject );
01367 }
01368
01369 {
01370 a2dArrow* arrow3 = new a2dArrow( 0,0,2, 2, 2 );
01371 arrow3->SetFill(wxColour(2,233,6));
01372 arrow3->SetStroke(wxColour(255,3,25 ),1);
01373 arrow3->SetSpecificFlags( true, a2dCanvasOFlags::normalized );
01374
01375 a2dLibraryReference* libobject = new a2dLibraryReference( 0, -400, arrow3, _T("arrow3"), 100);
01376 libobject->SetStroke(wxColour(229,5,64 ),0);
01377 m_librarypoints->Append( libobject );
01378 }
01379
01380 {
01381 a2dArrow* arrow3 = new a2dArrow( 0,0,2, 0, 2 );
01382 arrow3->SetFill(wxColour(2,233,6));
01383 arrow3->SetStroke(wxColour(255,3,25 ),1);
01384 arrow3->SetSpecificFlags( true, a2dCanvasOFlags::normalized );
01385
01386 a2dLibraryReference* libobject = new a2dLibraryReference( 0, -400, arrow3, _T("arrow4"), 100);
01387 libobject->SetStroke(wxColour(229,5,64 ),0);
01388 m_librarypoints->Append( libobject );
01389 }
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401 {
01402 a2dRect* rec3 = new a2dRect(-1,-1,2,2);
01403 rec3->SetFill(wxColour(0,120,240));
01404 rec3->SetStroke(wxColour(252,54,252 ),3.0);
01405 rec3->SetSpecificFlags( true, a2dCanvasOFlags::normalized );
01406
01407 a2dLibraryReference* libobject = new a2dLibraryReference( 200, -200, rec3, _T("rectangle"), 100);
01408 libobject->SetStroke(wxColour(229,5,64 ),0);
01409 m_librarypoints->Append( libobject );
01410 }
01411
01412 m_librarypoints->SetCanvasDocumentRecursive();
01413 #endif
01414 }
01415
01416 void a2dCentralCanvasCommandProcessor::OnBusyBegin( a2dCommandProcessorEvent& WXUNUSED(event) )
01417 {
01418 a2dCanvasView* drawer = CheckDrawer();
01419 if ( drawer )
01420 drawer->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_WAIT ) );
01421 }
01422
01423 void a2dCentralCanvasCommandProcessor::OnBusyEnd( a2dCommandProcessorEvent& WXUNUSED(event) )
01424 {
01425 a2dCanvasView* drawer = CheckDrawer();
01426 if ( drawer )
01427 drawer->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW ) );
01428 }
01429
01430 void a2dCentralCanvasCommandProcessor::OnActivateView( a2dViewEvent& viewevent )
01431 {
01432 a2dView* view = (a2dView*) viewevent.GetEventObject();
01433 SetActiveView( viewevent.GetActive() ? view : NULL );
01434
01435 if ( !m_currentDocument )
01436 return;
01437
01438 if ( !view )
01439 return;
01440
01441
01442
01443 }
01444
01445 void a2dCentralCanvasCommandProcessor::OnChangedDocument( a2dCommandEvent& event )
01446 {
01447 a2dCanvasDocument* doc = CheckCanvasDocument();
01448 if ( !doc )
01449 return;
01450
01451
01452 a2dGlobals->SetAberPolyToArc( double(m_AberPolyToArc)/doc->GetUnitsScale() );
01453 a2dGlobals->SetAberArcToPoly( double(m_AberArcToPoly)/doc->GetUnitsScale() );
01454 }
01455
01456 double a2dCentralCanvasCommandProcessor::GetUnitsScaleOfDocument()
01457 {
01458 a2dCanvasDocument* doc = CheckCanvasDocument();
01459 if ( !doc )
01460 return 1;
01461
01462 return doc->GetUnitsScale();
01463 }
01464
01465 void a2dCentralCanvasCommandProcessor::SetAberPolyToArc( const a2dDoMu& aber )
01466 {
01467 m_AberPolyToArc = aber;
01468 a2dCanvasDocument* doc = CheckCanvasDocument();
01469 if ( !doc )
01470 return;
01471
01472 a2dGlobals->SetAberPolyToArc( double(m_AberPolyToArc)/doc->GetUnitsScale() );
01473 }
01474
01475 void a2dCentralCanvasCommandProcessor::SetAberArcToPoly( const a2dDoMu& aber )
01476 {
01477 m_AberArcToPoly = aber;
01478 a2dCanvasDocument* doc = CheckCanvasDocument();
01479 if ( !doc )
01480 return;
01481
01482 a2dGlobals->SetAberArcToPoly( double(m_AberArcToPoly)/doc->GetUnitsScale() );
01483 }
01484
01485 void a2dCentralCanvasCommandProcessor::SetSmall( const a2dDoMu& smallest )
01486 {
01487 m_small = smallest;
01488 }
01489
01490 bool a2dCentralCanvasCommandProcessor::GdsIoSaveTextAsPolygon( bool onOff )
01491 {
01492 m_gdsiiSaveTextAsPolygon = onOff;
01493 const_forEachIn( a2dDocumentTemplateList, &GetDocTemplates() )
01494 {
01495 a2dDocumentTemplateList::value_type temp = *iter;
01496 if (temp->IsVisible() && wxT("GDS-II") == temp->GetDescription() )
01497 {
01498 #if wxART2D_USE_GDSIO
01499 wxStaticCast( temp->GetDocumentIOHandlerStrOut(), a2dIOHandlerGDSOut )->SetSaveTextAsVpath( m_gdsiiSaveTextAsPolygon );
01500 #endif //wxART2D_USE_GDSIO
01501 }
01502 }
01503 return true;
01504 }
01505
01506 bool a2dCentralCanvasCommandProcessor::KeyIoSaveTextAsPolygon( bool onOff )
01507 {
01508 m_keySaveTextAsPolygon = onOff;
01509 const_forEachIn( a2dDocumentTemplateList, &GetDocTemplates() )
01510 {
01511 a2dDocumentTemplateList::value_type temp = *iter;
01512 if (temp->IsVisible() && wxT("KEY") == temp->GetDescription() )
01513 {
01514 #if wxART2D_USE_KEYIO
01515 wxStaticCast( temp->GetDocumentIOHandlerStrOut(), a2dIOHandlerKeyOut )->SetSaveTextAsVpath( m_keySaveTextAsPolygon );
01516 #endif //wxART2D_USE_KEYIO
01517 }
01518 }
01519 return true;
01520 }
01521
01522 a2dCanvasObject* a2dCentralCanvasCommandProcessor::AddCurrent( a2dCanvasObject* objectToAdd, bool withUndo, a2dPropertyIdList* setStyles, a2dCanvasObject* parentObject )
01523 {
01524 if ( !m_currentDocument )
01525 return NULL;
01526
01527 if ( parentObject )
01528 m_parent = parentObject;
01529
01530 m_currentobject = objectToAdd;
01531
01532 if ( m_currentobject )
01533 m_currentobject->TakeOverProperties( this, setStyles );
01534
01535
01536 if ( withUndo )
01537 GetDocCmdh()->Submit( new a2dCommand_AddObject( m_parent, m_currentobject ) );
01538 else
01539 {
01540 if ( m_AppendOrPrepend )
01541 m_parent->Append( m_currentobject );
01542 else
01543 m_parent->Prepend( m_currentobject );
01544 }
01545
01546 return m_currentobject;
01547 }
01548
01549
01550 void a2dCentralCanvasCommandProcessor::SetCurrentCanvasObject( a2dCanvasObject* currentcanvasobject, bool takeOverProperties )
01551 {
01552 if ( !currentcanvasobject )
01553 currentcanvasobject = 0;
01554
01555 m_currentobject = currentcanvasobject;
01556 if ( !m_currentobject )
01557 return;
01558
01559 if ( !takeOverProperties )
01560 return;
01561
01562
01563
01564 a2dNamedPropertyList props;
01565 currentcanvasobject->CollectProperties2( &props, NULL, a2dPropertyId::flag_transfer );
01566 a2dNamedPropertyList::iterator iter;
01567 for( iter = props.begin(); iter != props.end(); ++iter )
01568 {
01569 a2dNamedProperty *prop = *iter;
01570 prop->SetToObjectClone( this );
01571 }
01572 }
01573
01574 void a2dCentralCanvasCommandProcessor::SetStroke( const a2dStroke& stroke )
01575 {
01576 a2dCentralCanvasCommandProcessor::PROPID_Stroke->SetPropertyToObject( this, stroke );
01577 }
01578
01579 void a2dCentralCanvasCommandProcessor::SetStroke(const unsigned char red, const unsigned char green, const unsigned char blue)
01580 {
01581 a2dCanvasObject* canobj = GetCurrentCanvasObject();
01582 a2dStroke col = GetStroke();
01583 col.SetColour( wxColour(red, green, blue) );
01584 Submit(new a2dCommand_SetCanvasProperty( canobj, a2dCanvasObject::PROPID_Stroke, col), m_withUndo );
01585 }
01586
01587 void a2dCentralCanvasCommandProcessor::SetFill( const a2dFill& fill )
01588 {
01589 a2dCentralCanvasCommandProcessor::PROPID_Fill->SetPropertyToObject( this, fill );
01590 }
01591
01592 void a2dCentralCanvasCommandProcessor::SetFill(const unsigned char red, const unsigned char green, const unsigned char blue)
01593 {
01594 a2dCanvasObject* canobj = GetCurrentCanvasObject();
01595 a2dFill col = GetFill();
01596 col.SetColour( wxColour(red, green, blue) );
01597 Submit(new a2dCommand_SetCanvasProperty( canobj, a2dCanvasObject::PROPID_Fill, col), m_withUndo );
01598 }
01599
01600 void a2dCentralCanvasCommandProcessor::SetFont( const a2dFont& font )
01601 {
01602 a2dCentralCanvasCommandProcessor::PROPID_Font->SetPropertyToObject( this, font );
01603
01604 a2dCanvasObject* canobj = GetCurrentCanvasObject();
01605 if ( wxDynamicCast( canobj, a2dText ) )
01606 {
01607
01608
01609 }
01610 }
01611
01612 void a2dCentralCanvasCommandProcessor::SetContourWidthInDataBaseUnits( double width )
01613 {
01614 a2dCanvasDocument* doc = CheckCanvasDocument();
01615 if ( !doc )
01616 m_currentContourWidth = 0.0;
01617 m_currentContourWidth = width * doc->GetUnitsScale();
01618 }
01619
01620
01621 double a2dCentralCanvasCommandProcessor::GetContourWidthInDataBaseUnits() const
01622 {
01623 a2dCanvasDocument* doc = CheckCanvasDocument();
01624 if ( !doc )
01625 return 0;
01626 return m_currentContourWidth/doc->GetUnitsScale();
01627 }
01628
01629 void a2dCentralCanvasCommandProcessor::SetContourWidth( const a2dDoMu& currentContourWidth )
01630 {
01631 m_currentContourWidth = currentContourWidth;
01632 }
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669
01670
01671 bool a2dCentralCanvasCommandProcessor::SetParentObject(a2dCanvasObject* obj )
01672 {
01673 a2dCanvasDocument* doc = CheckCanvasDocument();
01674 if ( !doc )
01675 return false;
01676
01677 if ( !obj )
01678 obj = CheckCanvasDocument()->GetRootObject();
01679
01680 if ( m_parent != obj )
01681 {
01682 a2dCanvasObject* found = doc->Find(obj);
01683
01684 if (!found)
01685 m_parent = doc->GetRootObject();
01686 else
01687 m_parent = found;
01688
01689 m_currentobject = 0;
01690
01691 return found != 0;
01692 }
01693 return true;
01694 }
01695
01696 a2dCanvasObject* a2dCentralCanvasCommandProcessor::Add_a2dCanvasObject( double x, double y )
01697 {
01698 if ( !CheckCanvasDocument() )
01699 return NULL;
01700
01701 return AddCurrent( new a2dCanvasObject( x, y ), m_withUndo );
01702 }
01703
01704 a2dCanvasObjectReference* a2dCentralCanvasCommandProcessor::Add_a2dCanvasObjectReference( double x, double y, a2dCanvasObject* obj )
01705 {
01706 if ( !CheckCanvasDocument() )
01707 return NULL;
01708
01709 return (a2dCanvasObjectReference*) AddCurrent( new a2dCanvasObjectReference( x, y, obj ), m_withUndo );
01710 }
01711
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722 a2dOrigin* a2dCentralCanvasCommandProcessor::Add_a2dOrigin( double w, double h )
01723 {
01724 if ( !CheckCanvasDocument() )
01725 return NULL;
01726
01727 return (a2dOrigin*) AddCurrent( new a2dOrigin( w, h ), m_withUndo );
01728 }
01729
01730 a2dHandle* a2dCentralCanvasCommandProcessor::Add_a2dHandle( double xc, double yc, int w, int h, double angle , int radius )
01731 {
01732 if ( !CheckCanvasDocument() )
01733 return NULL;
01734
01735 return (a2dHandle*) AddCurrent( new a2dHandle( NULL, xc, yc, _T(""), w, h, angle, radius ), m_withUndo );
01736 }
01737
01738 a2dRectC* a2dCentralCanvasCommandProcessor::Add_a2dRectC( double xc, double yc, double w, double h, double angle, double radius )
01739 {
01740 if ( !CheckCanvasDocument() )
01741 return NULL;
01742
01743 return (a2dRectC*) AddCurrent( new a2dRectC( xc, yc, w, h, angle, radius ), m_withUndo );
01744 }
01745
01746 a2dArrow* a2dCentralCanvasCommandProcessor::Add_a2dArrow( double xt, double yt, double l1, double l2, double b, bool spline )
01747 {
01748 if ( !CheckCanvasDocument() )
01749 return NULL;
01750
01751 return (a2dArrow*) AddCurrent( new a2dArrow( xt, yt, l1, l2, b, spline ), m_withUndo );
01752 }
01753
01754 a2dRect* a2dCentralCanvasCommandProcessor::Add_a2dRect( double x, double y, double w, double h , double radius )
01755 {
01756 if ( !CheckCanvasDocument() )
01757 return NULL;
01758
01759 return (a2dRect*) AddCurrent( new a2dRect( x, y, w, h, radius ), m_withUndo );
01760 }
01761
01762 a2dCircle* a2dCentralCanvasCommandProcessor::Add_a2dCircle( double x, double y, double radius )
01763 {
01764 if ( !CheckCanvasDocument() )
01765 return NULL;
01766
01767 return (a2dCircle*) AddCurrent( new a2dCircle( x, y, radius ), m_withUndo );
01768 }
01769
01770 a2dEllipse* a2dCentralCanvasCommandProcessor::Add_a2dEllipse( double xc, double yc, double width, double height )
01771 {
01772 if ( !CheckCanvasDocument() )
01773 return NULL;
01774
01775 return (a2dEllipse*) AddCurrent( new a2dEllipse( xc, yc, width, height ), m_withUndo );
01776 }
01777
01778 a2dEllipticArc* a2dCentralCanvasCommandProcessor::Add_a2dEllipticArc( double xc, double yc, double width, double height, double start, double end )
01779 {
01780 if ( !CheckCanvasDocument() )
01781 return NULL;
01782
01783 return (a2dEllipticArc*) AddCurrent( new a2dEllipticArc( xc, yc, width, height, start, end ), m_withUndo );
01784 }
01785
01786 a2dArc* a2dCentralCanvasCommandProcessor::Add_a2dArc( double xc, double yc, double radius, double start, double end )
01787 {
01788 if ( !CheckCanvasDocument() )
01789 return NULL;
01790
01791 return (a2dArc*) AddCurrent( new a2dArc( xc, yc, radius, start, end ), m_withUndo );
01792 }
01793
01794 a2dSLine* a2dCentralCanvasCommandProcessor::Add_a2dSLine( double x1, double y1, double x2, double y2 )
01795 {
01796 if ( !CheckCanvasDocument() )
01797 return NULL;
01798
01799 return (a2dSLine*) AddCurrent( new a2dSLine( x1, y1, x2, y2 ), m_withUndo );
01800 }
01801
01802 a2dEndsLine* a2dCentralCanvasCommandProcessor::Add_a2dEndsLine( double x1, double y1, double x2, double y2 )
01803 {
01804 if ( !CheckCanvasDocument() )
01805 return NULL;
01806
01807 return (a2dEndsLine*) AddCurrent( new a2dEndsLine( x1, y1, x2, y2 ), m_withUndo );
01808 }
01809
01810 a2dImage* a2dCentralCanvasCommandProcessor::Add_a2dImage( const wxImage &image, double xc, double yc, double w, double h )
01811 {
01812 if ( !CheckCanvasDocument() )
01813 return NULL;
01814
01815 return (a2dImage*) AddCurrent( new a2dImage( image, xc, yc, w, h ), m_withUndo );
01816 }
01817
01818 a2dImage* a2dCentralCanvasCommandProcessor::Add_a2dImage( const wxString &imagefile, wxBitmapType type, double xc, double yc, double w, double h )
01819 {
01820 if ( !CheckCanvasDocument() )
01821 return NULL;
01822
01823 return (a2dImage*) AddCurrent( new a2dImage( imagefile, type, xc, yc, w, h ), m_withUndo );
01824 }
01825
01826 a2dText* a2dCentralCanvasCommandProcessor::Add_a2dText( const wxString &text, double x, double y, double angle, const a2dFont& font )
01827 {
01828 if ( !CheckCanvasDocument() )
01829 return NULL;
01830
01831 return (a2dText*) AddCurrent( new a2dText( text, x, y, font, angle ), m_withUndo );
01832 }
01833
01834 a2dPolygonL* a2dCentralCanvasCommandProcessor::Add_a2dPolygonL(a2dVertexList* points, bool spline )
01835 {
01836 if ( !CheckCanvasDocument() )
01837 return NULL;
01838
01839 return (a2dPolygonL*) AddCurrent( new a2dPolygonL( points, spline ), m_withUndo );
01840 }
01841
01842 a2dPolylineL* a2dCentralCanvasCommandProcessor::Add_a2dPolylineL(a2dVertexList* points, bool spline )
01843 {
01844 if ( !CheckCanvasDocument() )
01845 return NULL;
01846
01847 return (a2dPolylineL*) AddCurrent( new a2dPolylineL( points, spline ), m_withUndo );
01848 }
01849
01850 bool a2dCentralCanvasCommandProcessor::Add_Point( double x, double y )
01851 {
01852 if ( !CheckCanvasDocument() )
01853 return false;
01854
01855 GetDocCmdh()->Submit( new a2dCommand_AddPoint( GetCurrentCanvasObject(), x, y, -1 ), m_withUndo );
01856
01857
01858
01859 return true;
01860 }
01861
01862 bool a2dCentralCanvasCommandProcessor::Move_Point( int index ,double x, double y )
01863 {
01864 if ( !CheckCanvasDocument() )
01865 return false;
01866
01867 GetDocCmdh()->Submit( new a2dCommand_MoveSegment( GetCurrentCanvasObject(), x, y, index ), m_withUndo );
01868
01869
01870
01871 return true;
01872 }
01873
01874 bool a2dCentralCanvasCommandProcessor::CvgString( const wxString& cvgString )
01875 {
01876 if ( !m_currentDocument )
01877 return false;
01878
01879 wxString cvgStringtoExecute = cvgString;
01880
01881 #if wxART2D_USE_CVGIO
01882 if ( cvgString.Contains( _T("<?xml") ) && cvgString.Contains( _T("<cvg") ) && cvgString.Contains( _T("</cvg>") ) )
01883 {
01884 }
01885 else
01886 {
01887 cvgStringtoExecute = _T("<?xml version=\"1.0\" standalone=\"yes\"?> <cvg classname=\"a2dCanvasDocument\"> ") + cvgString + _T(" </cvg>");
01888 }
01889
01890 #if wxUSE_STD_IOSTREAM
01891 #if wxUSE_UNICODE
01892 a2dDocumentStringInputStream stream( cvgStringtoExecute.mb_str().data(), wxSTD ios_base::in );
01893 #else
01894 a2dDocumentStringInputStream stream( cvgStringtoExecute.mb_str(), wxSTD ios_base::in );
01895 #endif // wxUSE_UNICODE
01896 #else
01897 a2dDocumentStringInputStream stream( cvgStringtoExecute );
01898 #endif
01899 a2dIOHandlerCVGIn CvgString;
01900
01901 return CvgString.Load( stream, (a2dCanvasDocument*) m_currentDocument, m_parent );
01902
01903 #else
01904 return false;
01905 #endif //wxART2D_USE_CVGIO
01906 }
01907
01908 void a2dCentralCanvasCommandProcessor::SetLayer( wxUint16 layer, bool setStyleOfLayer )
01909 {
01910
01911 m_layer = layer;
01912 if ( setStyleOfLayer )
01913 {
01914 m_currentfill = *a2dNullFILL;
01915 m_currentstroke = *a2dNullSTROKE;
01916 }
01917 }
01918
01919
01920
01921 bool a2dCentralCanvasCommandProcessor::SetPropertyToObject( const wxString& objectname, const wxString& propertyname, const wxString& value )
01922 {
01923 if ( objectname == _T("a2dBaseTool") )
01924 {
01925 if ( !m_currentDocument )
01926 return false;
01927
01928 a2dBaseTool* tool = GetActiveTool();
01929
01930 if ( tool )
01931 return GetDocCmdh()->SetOrAddPropertyToObject( tool, propertyname, value, m_withUndo );
01932
01933 return false;
01934 }
01935 else if ( objectname == _T("a2dToolContr") )
01936 {
01937 if ( !m_currentDocument )
01938 return false;
01939
01940 a2dCanvasView* drawer = CheckDrawer();
01941
01942 if ( drawer )
01943 {
01944 a2dToolContr* contr = drawer->GetCanvasToolContr();
01945 return GetDocCmdh()->SetOrAddPropertyToObject( contr, propertyname, value, m_withUndo );
01946 }
01947
01948 return false;
01949 }
01950 else if ( objectname == _T("a2dCanvasView") )
01951 {
01952 if ( !m_currentDocument )
01953 return false;
01954
01955 a2dCanvasView* drawer = CheckDrawer();
01956
01957 if ( drawer )
01958 return SetOrAddPropertyToObject( drawer, propertyname, value, m_withUndo );
01959 else
01960 a2dDocviewGlobals->ReportErrorF( a2dError_NoView, _("No a2dCanvasView View available") );
01961
01962 return false;
01963 }
01964 else if ( objectname == _T("a2dCanvasCommandProcessor") )
01965 {
01966 if ( !m_currentDocument )
01967 return false;
01968
01969 return GetDocCmdh()->SetOrAddPropertyToObject( GetDocCmdh(), propertyname, value, m_withUndo );
01970 }
01971 else if ( objectname == _T("a2dCentralCanvasCommandProcessor") )
01972 {
01973 if ( !m_currentDocument )
01974 return false;
01975
01976 return SetOrAddPropertyToObject(this, propertyname, value, m_withUndo );
01977 }
01978 return false;
01979 }
01980
01981 bool a2dCentralCanvasCommandProcessor::SetPropertyToObject( const wxString& objectname, a2dNamedProperty *property )
01982 {
01983
01984
01985
01986
01987
01988 if ( objectname == _T("a2dBaseTool") )
01989 {
01990 if ( !m_currentDocument )
01991 return false;
01992
01993 a2dBaseTool* tool = GetActiveTool();
01994
01995 if ( tool )
01996 return SetOrAddPropertyToObject( tool, property, m_withUndo );
01997
01998 return false;
01999 }
02000 else if ( objectname == _T("a2dToolContr") )
02001 {
02002 if ( !m_currentDocument )
02003 return false;
02004
02005 a2dCanvasView* drawer = CheckDrawer();
02006
02007 if ( drawer )
02008 {
02009 a2dToolContr* contr = drawer->GetCanvasToolContr();
02010 return SetOrAddPropertyToObject( contr, property, m_withUndo );
02011 }
02012
02013 return false;
02014 }
02015 else if ( objectname == _T("a2dCanvasView") )
02016 {
02017 if ( !m_currentDocument )
02018 return false;
02019
02020 a2dCanvasView* drawer = CheckDrawer();
02021
02022 if ( drawer )
02023 return SetOrAddPropertyToObject( drawer, property, m_withUndo );
02024 else
02025 a2dDocviewGlobals->ReportErrorF( a2dError_NoView, _("No a2dCanvasView View available") );
02026
02027 return false;
02028 }
02029 else if ( objectname == _T("a2dCanvasCommandProcessor") )
02030 {
02031 if ( !m_currentDocument )
02032 return false;
02033
02034 return GetDocCmdh()->SetOrAddPropertyToObject( GetDocCmdh(), property, m_withUndo );
02035 }
02036 else if ( objectname == _T("a2dCentralCanvasCommandProcessor") )
02037 {
02038 if ( !m_currentDocument )
02039 return false;
02040
02041 return SetOrAddPropertyToObject(this, property, m_withUndo );
02042 }
02043 return false;
02044 }
02045
02046 bool a2dCentralCanvasCommandProcessor::SetLayerProperty( long layer,
02047 const wxString& propertyname,
02048 const wxString& value
02049 )
02050 {
02051 if ( !m_currentDocument )
02052 return false;
02053
02054 a2dLayers* layers = ((a2dCanvasDocument*) m_currentDocument)->GetLayerSetup();
02055 if ( !layers )
02056 return false;
02057
02058 a2dLayerInfo* layerinfodoc = layers->GetLayerIndex()[ layer ];
02059
02060 bool res = GetDocCmdh()->SetOrAddPropertyToObject( layerinfodoc, propertyname, value, m_withUndo );
02061
02062 return res;
02063 }
02064
02065 a2dBaseTool* a2dCentralCanvasCommandProcessor::GetActiveTool()
02066 {
02067 a2dCanvasView* drawer = CheckDrawer();
02068
02069 if ( drawer )
02070 {
02071 a2dToolContr* contr = drawer->GetCanvasToolContr();
02072 return contr->GetFirstTool();
02073 }
02074 return NULL;
02075 }
02076
02077 a2dBaseTool* a2dCentralCanvasCommandProcessor::PopTool()
02078 {
02079 a2dCanvasView* drawer = CheckDrawer();
02080
02081 if ( drawer )
02082 {
02083 a2dToolContr* contr = drawer->GetCanvasToolContr();
02084 if ( contr )
02085 {
02086 a2dSmrtPtr< a2dBaseTool > tool;
02087 contr->PopTool( tool );
02088 if ( ! tool )
02089 a2dDocviewGlobals->ReportError( a2dError_NoTool );
02090 return (a2dBaseTool*) tool.Get();
02091 }
02092 a2dDocviewGlobals->ReportError( a2dError_NoController );
02093 return NULL;
02094 }
02095 a2dDocviewGlobals->ReportError( a2dError_NoView );
02096 return NULL;
02097 }
02098
02099
02100
02101 bool a2dCentralCanvasCommandProcessor::SetShowObject(int index)
02102 {
02103 a2dCanvasView* drawer = CheckDrawer();
02104 if ( drawer )
02105 {
02106 if ( !drawer->GetCanvasDocument() )
02107 {
02108 a2dDocviewGlobals->ReportError( a2dError_NoDocument );
02109 return false;
02110 }
02111
02112 a2dCanvasObject* top = drawer->GetCanvasDocument()->Find( _T(""), _T(""), index );
02113 if ( !top )
02114 {
02115 a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _T("No Object with id %d in a2dCentralCanvasCommandProcessor::SetShowObject()"), index );
02116 return false;
02117 }
02118 drawer->SetShowObject( top );
02119 return true;
02120 }
02121
02122 a2dDocviewGlobals->ReportError( a2dError_NoView );
02123 return false;
02124 }
02125
02126 void a2dCentralCanvasCommandProcessor::SetGridX( const a2dDoMu& gridX )
02127 {
02128 m_gridX = gridX;
02129 a2dCanvasView* drawer = CheckDrawer();
02130 if ( drawer )
02131 {
02132 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
02133 if ( !doc )
02134 return;
02135
02136 drawer->SetGridX( double( m_gridX )/doc->GetUnitsScale() );
02137 }
02138 }
02139
02140 void a2dCentralCanvasCommandProcessor::SetGridY( const a2dDoMu& gridY )
02141 {
02142 m_gridY = gridY;
02143 a2dCanvasView* drawer = CheckDrawer();
02144 if ( drawer )
02145 {
02146 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
02147 if ( !doc )
02148 return;
02149
02150 drawer->SetGridY( double( m_gridY )/doc->GetUnitsScale() );
02151 }
02152 }
02153
02154
02155 bool a2dCentralCanvasCommandProcessor::Zoom( double x1,double y1, double x2, double y2, bool upp )
02156 {
02157 a2dCanvasView* drawer = CheckDrawer();
02158 if ( drawer )
02159 {
02160 if ( !upp )
02161 drawer->GetDrawer2D()->SetMappingWidthHeight( x1, y1, x2, y2 );
02162 else
02163 drawer->GetDrawer2D()->SetMappingUpp( x1, y1, x2, y2 );
02164 return true;
02165 }
02166
02167 a2dDocviewGlobals->ReportError( a2dError_NoView );
02168 return false;
02169 }
02170
02171 bool a2dCentralCanvasCommandProcessor::Update()
02172 {
02173 a2dCanvasView* drawer = CheckDrawer();
02174 if ( drawer )
02175 {
02176 drawer->Update( a2dCANVIEW_UPDATE_ALL | a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT );
02177 return true;
02178 }
02179
02180 a2dDocviewGlobals->ReportError( a2dError_NoView );
02181 return false;
02182 }
02183
02184 bool a2dCentralCanvasCommandProcessor::Select( double x1,double y1, double x2, double y2 )
02185 {
02186 a2dCanvasView* drawer = CheckDrawer();
02187 if ( drawer )
02188 {
02189 GetDocCmdh()->Submit(new a2dCommand_SetFlags( m_parent, a2dCanvasOFlags::SELECTED, true, a2dBoundingBox( x1, y1, x2, y2 )), m_withUndo );
02190 return true;
02191 }
02192
02193 a2dDocviewGlobals->ReportError( a2dError_NoView );
02194 return false;
02195 }
02196
02197 bool a2dCentralCanvasCommandProcessor::DeSelect( double x1,double y1, double x2, double y2 )
02198 {
02199 a2dCanvasView* drawer = CheckDrawer();
02200 if ( drawer )
02201 {
02202 GetDocCmdh()->Submit(new a2dCommand_SetFlags( m_parent, a2dCanvasOFlags::SELECTED, false, a2dBoundingBox( x1, y1, x2, y2 )), m_withUndo );
02203 return true;
02204 }
02205
02206 a2dDocviewGlobals->ReportError( a2dError_NoView );
02207 return false;
02208 }
02209
02210 a2dCanvasView* a2dCentralCanvasCommandProcessor::CheckDrawer() const
02211 {
02212 if ( !m_currentDocument )
02213 return NULL;
02214
02215 if ( !GetLastView() )
02216 {
02217 return NULL;
02218 }
02219
02220 return wxDynamicCast( GetLastView(), a2dCanvasView );
02221 }
02222
02223 a2dCanvasDocument* a2dCentralCanvasCommandProcessor::CheckCanvasDocument() const
02224 {
02225 return wxDynamicCast( m_currentDocument, a2dCanvasDocument );
02226 }
02227
02228
02229
02230
02231
02232 IMPLEMENT_CLASS( a2dCanvasCommandProcessor, a2dCommandProcessor );
02233
02234
02235 a2dCanvasCommandProcessor::a2dCanvasCommandProcessor( a2dCanvasDocument* doc, int maxCommands )
02236 : a2dCommandProcessor( maxCommands )
02237 {
02238 m_doc = doc;
02239
02240 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
02241 CurrentSmartPointerOwner = this;
02242 #endif
02243 }
02244
02245 a2dCanvasCommandProcessor::~a2dCanvasCommandProcessor()
02246 {
02247 if ( m_doc && m_doc->GetCommandProcessor() == this )
02248 m_doc->SetCommandProcessor( 0 );
02249 }
02250
02251
02252 bool a2dCanvasCommandProcessor::Submit( a2dCommand*command, bool storeIt )
02253 {
02254 wxCHECK_MSG( command, false, _T("no command in a2dCanvasCommandProcessor::Submit") );
02255
02256 SentBusyEvent( true, command );
02257
02258
02259 a2dSmrtPtr<a2dCommand> lcommand = command;
02260
02261 (( a2dCommand* )command)->SetCommandProcessor( this );
02262 if ( command->IsCommandGroup() )
02263 {
02264 wxStaticCast( command, a2dCommandGroup )->SetParentGroup( m_currentGroup );
02265 }
02266
02267
02268 if ( storeIt )
02269 Store(command);
02270
02271 if ( !DoCommand(*command) )
02272 {
02273 if ( storeIt )
02274 {
02275 m_currentGroup->Remove( command );
02276 SetCurrentToLastActive();
02277 }
02278
02279 SentBusyEvent( false, command );
02280
02281 return false;
02282 }
02283
02284
02285
02286
02287
02288
02289
02290 GetCanvasDocument()->Modify(true);
02291
02292
02293
02294
02295
02296
02297 SentBusyEvent( false, command );
02298 return true;
02299 }
02300
02301 bool a2dCanvasCommandProcessor::SubmitMultiple( a2dCommand* command, a2dCanvasObjectList* objects, bool storeIt )
02302 {
02303 bool result = true;
02304
02305 if( objects->size() )
02306 {
02307 a2dCommandGroup *group = 0;
02308
02309 if( storeIt )
02310 group = CommandGroupBegin( _("Multiple ") + command->GetName() );
02311
02312 for( a2dCanvasObjectList::iterator iter = objects->begin(); iter != objects->end(); ++iter )
02313 {
02314 a2dCanvasObject *obj = *iter;
02315 a2dCommand*clone = command->CloneAndBind( obj );
02316
02317 if( !Submit( clone, storeIt ) )
02318 result = false;
02319 }
02320
02321 if( storeIt )
02322 CommandGroupEnd( group );
02323 }
02324
02325 delete command;
02326
02327 return result;
02328 }
02329
02330 a2dCanvasObjectList* a2dCanvasCommandProcessor::ConvertToPolygons( a2dCanvasObject* canvasobject, bool transform )
02331 {
02332 a2dCanvasObjectList* polylist = NULL;
02333
02334 a2dCanvasObjectList* vpath = ConvertToVpath( canvasobject, true );
02335
02336
02337
02338 if ( vpath != wxNullCanvasObjectList )
02339 {
02340 a2dCanvasObjectList::iterator iter = vpath->begin();
02341 while ( iter != vpath->end() )
02342 {
02343 a2dVectorPath* obj = (a2dVectorPath*) (*iter).Get();
02344 polylist = obj->GetAsPolygons();
02345
02346 iter = vpath->erase( iter );
02347 iter = vpath->begin();
02348 }
02349 delete vpath;
02350 }
02351 return polylist;
02352 }
02353
02354 a2dCanvasObjectList* a2dCanvasCommandProcessor::ConvertToVpath( a2dCanvasObject* canvasobject, bool transform )
02355 {
02356 a2dCanvasObjectList* vpath = wxNullCanvasObjectList;
02357
02358 if ( wxDynamicCast( canvasobject, a2dRect ) ||
02359 wxDynamicCast( canvasobject, a2dRectC ) ||
02360 wxDynamicCast( canvasobject, a2dArrow ) ||
02361 wxDynamicCast( canvasobject, a2dCircle ) ||
02362 wxDynamicCast( canvasobject, a2dEllipse ) ||
02363 wxDynamicCast( canvasobject, a2dEllipticArc ) ||
02364 wxDynamicCast( canvasobject, a2dArc ) ||
02365 wxDynamicCast( canvasobject, a2dPolygonL ) ||
02366 wxDynamicCast( canvasobject, a2dVectorPath ) ||
02367 wxDynamicCast( canvasobject, a2dText ) ||
02368 wxDynamicCast( canvasobject, a2dEndsLine ) ||
02369 wxDynamicCast( canvasobject, a2dSLine ) ||
02370 wxDynamicCast( canvasobject, a2dPolylineL )
02371 )
02372 {
02373 vpath = canvasobject->GetAsCanvasVpaths( transform );
02374 }
02375 return vpath;
02376 }
02377
02378
02379
02380
02381
02382 a2dCommand_AddObject::a2dCommand_AddObject( a2dCanvasObject* parent, a2dCanvasObject* object ):
02383 a2dCommand( true, a2dCommand_AddObject::Id )
02384 {
02385 wxASSERT( !m_canvasobject );
02386 wxASSERT( !m_parent );
02387
02388 m_canvasobject = object;
02389 m_parent = parent;
02390 }
02391
02392 a2dCommand_AddObject::~a2dCommand_AddObject(void)
02393 {
02394 }
02395
02396 bool a2dCommand_AddObject::Do(void)
02397 {
02398
02399 m_canvasobject->SetRelease( false );
02400
02401 m_canvasobject->SetParent( m_parent );
02402 m_parent->Append( m_canvasobject );
02403 m_canvasobject->ReWireConnected( m_parent, true );
02404
02405 return true;
02406 }
02407
02408 bool a2dCommand_AddObject::Undo(void)
02409 {
02410
02411 m_canvasobject->SetParent( 0 );
02412 m_parent->ReleaseChild( m_canvasobject, false, false );
02413
02414 return true;
02415 }
02416
02417
02418
02419
02420
02421 a2dCommand_ReleaseObject::a2dCommand_ReleaseObject( a2dCanvasObject* parent, a2dCanvasObject *object, bool now ):
02422 a2dCommand( true, a2dCommand_ReleaseObject::Id )
02423 {
02424 m_canvasobject = object;
02425 m_parent = parent;
02426
02427 m_index = 0;
02428 m_now = now;
02429 }
02430
02431 a2dCommand_ReleaseObject::~a2dCommand_ReleaseObject(void)
02432 {
02433 }
02434
02435 bool a2dCommand_ReleaseObject::Do(void)
02436 {
02437 m_index = m_parent->IndexOf( m_canvasobject.Get() );
02438
02439 if ( m_index == -1 )
02440 a2dDocviewGlobals->ReportError( a2dError_canvasObjectRelease );
02441
02442 if ( m_now )
02443 m_parent->ReleaseChild( m_canvasobject.Get(), false, false, true );
02444 else
02445 {
02446
02447
02448 a2dCanvasObject::PROPID_Parent->SetPropertyToObject( m_canvasobject, m_parent );
02449 m_canvasobject->SetRelease( true );
02450 }
02451
02452 return true;
02453 }
02454
02455 bool a2dCommand_ReleaseObject::Undo(void)
02456 {
02457
02458
02459 m_canvasobject->SetRelease( false );
02460
02461
02462 m_parent->Insert( m_index, m_canvasobject.Get(), false );
02463
02464 return true;
02465 }
02466
02467
02468
02469
02470 a2dCommand_ReplaceObject::a2dCommand_ReplaceObject( a2dCanvasObject* parent, a2dCanvasObject* oldobject, a2dCanvasObject* newobject ):
02471 a2dCommand( true, a2dCommand_ReplaceObject::Id )
02472 {
02473 m_parent = parent;
02474 m_canvasobject = oldobject;
02475 m_canvasobject2 = newobject;
02476 m_parent = parent;
02477 }
02478
02479 a2dCommand_ReplaceObject::~a2dCommand_ReplaceObject(void)
02480 {
02481 }
02482
02483 bool a2dCommand_ReplaceObject::Do(void)
02484 {
02485 int index = m_parent->IndexOf( m_canvasobject );
02486
02487
02488 m_parent->ReleaseChild( m_canvasobject, false, false );
02489
02490 m_parent->Insert( index, m_canvasobject2 );
02491
02492 a2dCanvasObject* swap = m_canvasobject;
02493 m_canvasobject = m_canvasobject2;
02494 m_canvasobject2 = swap;
02495
02496 return true;
02497 }
02498
02499 bool a2dCommand_ReplaceObject::Undo(void)
02500 {
02501 return Do();
02502 }
02503
02504
02505
02506
02507
02508 a2dCommand_SetFlags::a2dCommand_SetFlags( a2dCanvasObject* parent, a2dCanvasObjectFlagsMask mask, bool value, const a2dBoundingBox& bbox ):
02509 a2dCommand( true, a2dCommand_SetFlags::Id )
02510 {
02511 m_parent = parent;
02512 m_bbox = bbox;
02513
02514 m_mask = mask;
02515
02516 m_objects = wxNullCanvasObjectList;
02517
02518 m_bool = value;
02519 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
02520
02521 CurrentSmartPointerOwner = this;
02522 #endif
02523 }
02524
02525 a2dCommand_SetFlags::~a2dCommand_SetFlags(void)
02526 {
02527 if ( m_objects != wxNullCanvasObjectList )
02528 delete m_objects;
02529 }
02530
02531 bool a2dCommand_SetFlags::Do(void)
02532 {
02533 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
02534 if ( !doc )
02535 return false;
02536
02537 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
02538 if ( !drawer )
02539 return false;
02540
02541 if ( ! m_parent )
02542 m_parent = drawer->GetShowObject();
02543
02544 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
02545 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, NULL, m_bbox );
02546
02547 if ( m_objects != wxNullCanvasObjectList )
02548 {
02549 forEachIn( a2dCanvasObjectList, m_objects )
02550 {
02551 a2dCanvasObject *obj = *iter;
02552 m_objectOldMask.push_back( obj->GetFlags() );
02553 }
02554
02555 a2dAffineMatrix tworld;
02556 objects->SetSpecificFlags( m_bool, m_mask, _T(""), a2dCanvasOFlags::ALL, m_bbox, tworld );
02557
02558
02559 objects->SetSpecificFlags( true, a2dCanvasOFlags::PENDING, _T(""), a2dCanvasOFlags::ALL, m_bbox, tworld );
02560 }
02561 m_parent->GetCanvasDocument()->SetUpdatesPending(true);
02562
02563 return true;
02564 }
02565
02566 bool a2dCommand_SetFlags::Undo(void)
02567 {
02568 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
02569 if ( m_objects != wxNullCanvasObjectList )
02570 {
02571 a2dlist< a2dCanvasObjectFlagsMask >::iterator itermask = m_objectOldMask.begin();
02572 while ( itermask != m_objectOldMask.end() )
02573 {
02574 forEachIn( a2dCanvasObjectList, m_objects )
02575 {
02576 a2dCanvasObject *obj = *iter;
02577 obj->SetFlags( *itermask );
02578 obj->SetPending( true );
02579 itermask++;
02580 }
02581 }
02582 }
02583 m_objects->clear();
02584 return true;
02585 }
02586
02587
02588
02589
02590
02591 a2dCommand_SetFlag::a2dCommand_SetFlag( a2dCanvasObject* object, a2dCanvasObjectFlagsMask which, bool value ):
02592 a2dCommand( true, a2dCommand_SetFlag::Id )
02593 {
02594 m_which = which;
02595 m_bool = value;
02596 m_canvasobject = object;
02597 }
02598
02599 a2dCommand_SetFlag::~a2dCommand_SetFlag(void)
02600 {
02601 }
02602
02603 a2dCommand* a2dCommand_SetFlag::CloneAndBind( a2dPropObject *object )
02604 {
02605 wxASSERT( !m_canvasobject );
02606 return new a2dCommand_SetFlag( wxStaticCast( object, a2dCanvasObject ), m_which, m_bool );
02607 }
02608
02609 bool a2dCommand_SetFlag::Do(void)
02610 {
02611
02612
02613 bool oldvalue = m_canvasobject->GetSelected();
02614
02615 m_canvasobject->SetSpecificFlags( m_bool, m_which );
02616
02617
02618 m_canvasobject->SetPending( true );
02619
02620 m_bool = oldvalue;
02621 return true;
02622 }
02623
02624 bool a2dCommand_SetFlag::Undo(void)
02625 {
02626 bool oldvalue = m_canvasobject->GetSelected();
02627
02628 m_canvasobject->SetSpecificFlags( m_bool, m_which );
02629
02630
02631 m_canvasobject->SetPending( true );
02632
02633 m_bool = oldvalue;
02634
02635 return true;
02636 }
02637
02638
02639
02640
02641
02642 a2dCommand_SetSelectFlag::a2dCommand_SetSelectFlag( a2dCanvasObject* object, bool value ):
02643 a2dCommand( true, a2dCommand_SetSelectFlag::Id )
02644 {
02645 m_bool = value;
02646 m_canvasobject = object;
02647 }
02648
02649 a2dCommand_SetSelectFlag::~a2dCommand_SetSelectFlag(void)
02650 {
02651 }
02652
02653 a2dCommand* a2dCommand_SetSelectFlag::CloneAndBind( a2dPropObject *object )
02654 {
02655 wxASSERT( !m_canvasobject );
02656 return new a2dCommand_SetSelectFlag( wxStaticCast( object, a2dCanvasObject ), m_bool );
02657 }
02658
02659 bool a2dCommand_SetSelectFlag::Do(void)
02660 {
02661
02662 bool oldvalue = m_canvasobject->GetSelected();
02663
02664 if ( m_canvasobject->GetCanvasDocument()->GetLayerSetup()->GetSelectable( m_canvasobject->GetLayer() ) )
02665 {
02666 m_canvasobject->SetSpecificFlags( m_bool, a2dCanvasOFlags::SELECTED );
02667
02668
02669 m_canvasobject->SetPending( true );
02670 }
02671
02672 m_bool = oldvalue;
02673 return true;
02674 }
02675
02676 bool a2dCommand_SetSelectFlag::Undo(void)
02677 {
02678 bool oldvalue = m_canvasobject->GetSelected();
02679
02680 m_canvasobject->SetSpecificFlags( m_bool, a2dCanvasOFlags::SELECTED );
02681
02682
02683 m_canvasobject->SetPending( true );
02684
02685 m_bool = oldvalue;
02686
02687 return true;
02688 }
02689
02690
02691
02692
02693
02694
02695 a2dCommand_TransformMask::a2dCommand_TransformMask( const a2dAffineMatrix& newtransform,
02696 a2dCanvasObjectFlagsMask which, a2dCanvasObject* parent ):
02697 a2dCommand( true, a2dCommand_TransformMask::Id )
02698 {
02699 m_parent = parent;
02700 m_objectsMatrix;
02701 m_which = which;
02702 m_transform = newtransform;
02703 }
02704
02705 a2dCommand_TransformMask::~a2dCommand_TransformMask(void)
02706 {
02707 }
02708
02709 bool a2dCommand_TransformMask::Do(void)
02710 {
02711
02712 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
02713 if ( !doc )
02714 return false;
02715
02716 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
02717 if ( !drawer )
02718 return false;
02719
02720 if ( !m_parent )
02721 m_parent = drawer->GetShowObject();
02722
02723 for( a2dCanvasObjectList::iterator iter = m_parent->GetChildObjectList()->begin();
02724 iter != m_parent->GetChildObjectList()->end(); ++iter )
02725 {
02726 a2dCanvasObject *obj = *iter;
02727 if (obj->CheckMask( m_which ))
02728 {
02729 m_objectsMatrix.push_back( a2dCommandMatrixData( m_parent, obj, obj->GetTransformMatrix() ) );
02730
02731
02732 obj->Transform( m_transform );
02733 }
02734 }
02735
02736
02737
02738 return true;
02739 }
02740
02741 bool a2dCommand_TransformMask::Undo(void)
02742 {
02743
02744 a2dAffineMatrix inverse = m_transform;
02745 inverse.Invert();
02746 a2dObjectMatrixList::iterator iter = m_objectsMatrix.begin();
02747 while ( iter != m_objectsMatrix.end() )
02748 {
02749 a2dCommandMatrixData obj = *iter;
02750 obj.m_object->Transform( inverse );
02751
02752 iter++;
02753 }
02754
02755 return true;
02756 }
02757
02758
02759
02760
02761
02762 a2dCommand_AddPoint::a2dCommand_AddPoint( a2dCanvasObject* object, double x, double y, int index, bool afterinversion ):
02763 a2dCommand( true, a2dCommand_AddPoint::Id )
02764 {
02765 m_x = x;
02766 m_y = y;
02767
02768 m_canvasobject = object;
02769 m_afterinversion = afterinversion;
02770 }
02771
02772 a2dCommand_AddPoint::a2dCommand_AddPoint( a2dCanvasObject* object, double x, double y, a2dLineSegmentPtr seg, bool afterinversion ):
02773 a2dCommand( true, a2dCommand_AddPoint::Id )
02774 {
02775 m_x = x;
02776 m_y = y;
02777 m_seg = seg;
02778
02779 m_canvasobject = object;
02780 m_afterinversion = afterinversion;
02781 }
02782
02783 a2dCommand_AddPoint::~a2dCommand_AddPoint(void)
02784 {
02785 }
02786
02787 bool a2dCommand_AddPoint::Do(void)
02788 {
02789
02790 if ( wxDynamicCast( m_canvasobject.Get(), a2dPolygonL ) )
02791 {
02792 a2dPolygonL* obj = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
02793 obj->AddPoint( m_x, m_y, m_seg, m_afterinversion );
02794 }
02795 return true;
02796 }
02797
02798 bool a2dCommand_AddPoint::Undo(void)
02799 {
02800 if ( wxDynamicCast( m_canvasobject.Get(), a2dPolygonL ) )
02801 {
02802 a2dPolygonL* obj = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
02803 obj->RemoveSegment( m_x, m_y, m_seg, m_afterinversion );
02804 }
02805 return true;
02806 }
02807
02808
02809
02810
02811
02812 a2dCommand_MoveSegment::a2dCommand_MoveSegment( a2dCanvasObject* object, double x, double y, int index, bool afterinversion ):
02813 a2dCommand( true, a2dCommand_MoveSegment::Id )
02814 {
02815 m_x = x;
02816 m_y = y;
02817
02818 m_canvasobject = object;
02819
02820 m_afterinversion = afterinversion;
02821 }
02822
02823 a2dCommand_MoveSegment::a2dCommand_MoveSegment( a2dCanvasObject* object, double x, double y, a2dLineSegmentPtr seg, bool afterinversion ):
02824 a2dCommand( true, a2dCommand_MoveSegment::Id )
02825 {
02826 m_x = x;
02827 m_y = y;
02828 m_seg = seg;
02829
02830 m_canvasobject = object;
02831
02832 m_afterinversion = afterinversion;
02833 }
02834
02835 a2dCommand_MoveSegment::~a2dCommand_MoveSegment(void)
02836 {
02837 }
02838
02839 bool a2dCommand_MoveSegment::Do(void)
02840 {
02841
02842 if ( wxDynamicCast( m_canvasobject.Get(), a2dPolygonL ) )
02843 {
02844 a2dPolygonL* obj = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
02845 double x, y;
02846 obj->GetPosXYSegment( m_seg, x, y, m_afterinversion );
02847 obj->SetPosXYSegment( m_seg, m_x, m_y, m_afterinversion );
02848
02849
02850 m_x = x;
02851 m_y = y;
02852 }
02853 else if ( wxDynamicCast( m_canvasobject.Get(), a2dSLine ))
02854 {
02855
02856
02857
02858
02859
02860
02861
02862
02863
02864
02865
02866
02867
02868
02869
02870
02871
02872
02873
02874 }
02875
02876 return true;
02877 }
02878
02879 bool a2dCommand_MoveSegment::Undo(void)
02880 {
02881
02882 bool result = Do();
02883
02884
02885
02886
02887
02888 return result;
02889 }
02890
02891
02892
02893
02894
02895 a2dCommand_MoveMidSegment::a2dCommand_MoveMidSegment( a2dCanvasObject* object, double x, double y, a2dLineSegmentPtr seg, bool afterinversion ):
02896 a2dCommand( true, a2dCommand_MoveMidSegment::Id )
02897 {
02898 m_x = x;
02899 m_y = y;
02900 m_seg = seg;
02901
02902 m_canvasobject = object;
02903
02904 m_afterinversion = afterinversion;
02905 }
02906
02907 a2dCommand_MoveMidSegment::a2dCommand_MoveMidSegment( a2dCanvasObject* object, double x, double y, int index, bool afterinversion ):
02908 a2dCommand( true, a2dCommand_MoveMidSegment::Id )
02909 {
02910 m_x = x;
02911 m_y = y;
02912
02913 m_canvasobject = object;
02914
02915 m_afterinversion = afterinversion;
02916 }
02917
02918 a2dCommand_MoveMidSegment::~a2dCommand_MoveMidSegment(void)
02919 {
02920 }
02921
02922 bool a2dCommand_MoveMidSegment::Do(void)
02923 {
02924
02925 if ( wxDynamicCast( m_canvasobject.Get(), a2dPolygonL ) )
02926 {
02927 a2dPolygonL* obj = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
02928 double x, y;
02929 obj->GetPosXYMidSegment( m_seg, x, y, m_afterinversion );
02930 obj->SetPosXYMidSegment( m_seg, m_x, m_y, m_afterinversion );
02931
02932
02933 m_x = x;
02934 m_y = y;
02935 }
02936
02937 GetCanvasCmp()->GetCanvasDocument()->Modify(true);
02938
02939 return true;
02940 }
02941
02942 bool a2dCommand_MoveMidSegment::Undo(void)
02943 {
02944
02945 bool result = Do();
02946
02947 return result;
02948 }
02949
02950
02951
02952
02953
02954 a2dCommand_RemoveSegment::a2dCommand_RemoveSegment( a2dCanvasObject* object, int index ):
02955 a2dCommand( true, a2dCommand_RemoveSegment::Id )
02956 {
02957 m_canvasobject = object;
02958 m_index = 0;
02959 }
02960
02961 a2dCommand_RemoveSegment::a2dCommand_RemoveSegment( a2dCanvasObject* object, a2dLineSegmentPtr seg ):
02962 a2dCommand( true, a2dCommand_RemoveSegment::Id )
02963 {
02964 m_seg = seg;
02965 if ( wxDynamicCast( object, a2dPolygonL ) )
02966 {
02967 a2dPolygonL* obj = wxStaticCast( object, a2dPolygonL );
02968 m_index = obj->GetIndexSegment( seg );
02969 }
02970
02971 m_canvasobject = object;
02972 }
02973
02974 a2dCommand_RemoveSegment::~a2dCommand_RemoveSegment(void)
02975 {
02976 }
02977
02978 bool a2dCommand_RemoveSegment::Do(void)
02979 {
02980
02981 if ( wxDynamicCast( m_canvasobject.Get(), a2dPolygonL ) )
02982 {
02983 a2dPolygonL* obj = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
02984 double x,y;
02985 obj->RemoveSegment( x, y, m_seg, false );
02986 }
02987 return true;
02988 }
02989
02990 bool a2dCommand_RemoveSegment::Undo(void)
02991 {
02992 if ( wxDynamicCast( m_canvasobject.Get(), a2dPolygonL ) )
02993 {
02994 a2dPolygonL* obj = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
02995 obj->InsertSegment( m_index, m_seg );
02996 }
02997 return true;
02998 }
02999
03000
03001
03002
03003
03004 a2dCommand_SetSegments::a2dCommand_SetSegments( a2dCanvasObject* object, a2dVertexList *points, bool afterinversion )
03005 : a2dCommand( true, a2dCommand_SetSegments::Id )
03006 {
03007 m_canvasobject = object;
03008 m_segments = points;
03009
03010 if( afterinversion )
03011 {
03012
03013 a2dAffineMatrix trans = object->GetTransformMatrix();
03014 trans.Invert();
03015 m_segments->Transform( trans );
03016 }
03017 }
03018
03019 a2dCommand_SetSegments::~a2dCommand_SetSegments(void)
03020 {
03021 }
03022
03023 bool a2dCommand_SetSegments::Do(void)
03024 {
03025 if ( wxDynamicCast( m_canvasobject.Get(), a2dPolygonL ) )
03026 {
03027 a2dPolygonL* obj = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
03028 a2dSmrtPtr<a2dVertexList> old = obj->GetSegments();
03029 obj->SetSegments( m_segments );
03030 m_segments = old;
03031 m_canvasobject->SetPending( true );
03032 }
03033 else
03034 {
03035
03036 wxASSERT( 0 );
03037 }
03038
03039 return true;
03040 }
03041
03042 bool a2dCommand_SetSegments::Undo(void)
03043 {
03044
03045 return Do();
03046 }
03047
03048
03049
03050
03051
03052 a2dCommand_ChangeText::a2dCommand_ChangeText( a2dText* object,
03053 wxString text, int caret, const a2dFont& font, double linespace, unsigned int textflags )
03054 : a2dCommand( true, a2dCommand_ChangeText::Id )
03055 {
03056 m_canvasobject = object;
03057 m_text = text;
03058 m_caret = caret;
03059 m_font = font;
03060 m_linespace = linespace;
03061 m_textflags = textflags;
03062 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
03063
03064 CurrentSmartPointerOwner = this;
03065 #endif
03066 }
03067
03068 a2dCommand_ChangeText::~a2dCommand_ChangeText(void)
03069 {
03070 }
03071
03072 bool a2dCommand_ChangeText::Do(void)
03073 {
03074 wxString oldtext = m_canvasobject->GetText();
03075 int oldcaret = m_canvasobject->GetCaret();
03076 a2dFont oldfont = m_canvasobject->GetFont();
03077 double oldlinespace = m_canvasobject->GetLineSpacing();
03078 unsigned int oldtextflags = m_canvasobject->GetTextFlags();
03079
03080 m_canvasobject->SetText( m_text );
03081 m_canvasobject->SetCaret( m_caret );
03082 m_canvasobject->SetFont( m_font );
03083 m_canvasobject->SetLineSpacing( m_linespace );
03084 m_canvasobject->SetTextFlags( (a2dText::a2dTextFlags) m_textflags );
03085
03086 m_text = oldtext;
03087 m_caret = oldcaret;
03088 m_font = oldfont;
03089 m_linespace = oldlinespace;
03090 m_textflags = oldtextflags;
03091
03092 return true;
03093 }
03094
03095 bool a2dCommand_ChangeText::Undo(void)
03096 {
03097 m_canvasobject->SetText( m_text );
03098 m_canvasobject->SetCaret( m_caret );
03099 m_canvasobject->SetFont( m_font );
03100 m_canvasobject->SetLineSpacing( m_linespace );
03101 m_canvasobject->SetTextFlags( (a2dText::a2dTextFlags) m_textflags );
03102
03103
03104 return true;
03105 }
03106
03107
03108
03109
03110
03111 const a2dCommandId a2dCommand_ChangeCentralStyle::sm_SetFillStyleCommand = a2dCommandId( wxT("SetFillStyleCommand") );
03112 const a2dCommandId a2dCommand_ChangeCentralStyle::sm_SetStrokeStyleCommand = a2dCommandId( wxT("SetStrokeStyleCommand") );
03113 const a2dCommandId a2dCommand_ChangeCentralStyle::sm_SetStyleCommand = a2dCommandId( wxT("SetStyleCommand") );
03114
03115
03116
03117
03118 a2dCommand_ChangeCentralStyle::a2dCommand_ChangeCentralStyle( a2dPropObject* object, const a2dFill& fill ):
03119 a2dCommand( true, sm_SetFillStyleCommand, sm_SetStyleCommand )
03120 {
03121 m_fill = fill;
03122 m_stroke = *a2dNullSTROKE;
03123
03124 m_propObject = object;
03125 }
03126
03127 a2dCommand_ChangeCentralStyle::a2dCommand_ChangeCentralStyle( a2dPropObject* object, const a2dStroke& stroke ):
03128 a2dCommand( true, sm_SetStrokeStyleCommand, sm_SetStyleCommand )
03129 {
03130 m_fill = *a2dNullFILL;
03131 m_stroke = stroke;
03132
03133 m_propObject = object;
03134 }
03135
03136 a2dCommand_ChangeCentralStyle::a2dCommand_ChangeCentralStyle( a2dPropObject* object,
03137 const a2dFill& fill, const a2dStroke& stroke ):
03138 a2dCommand( true, sm_SetStyleCommand, sm_SetStyleCommand )
03139 {
03140 m_fill = fill;
03141 m_stroke = stroke;
03142
03143 m_propObject = object;
03144 }
03145
03146
03147 a2dCommand_ChangeCentralStyle::~a2dCommand_ChangeCentralStyle(void)
03148 {
03149 }
03150
03151 bool a2dCommand_ChangeCentralStyle::Do(void)
03152 {
03153 if ( !m_fill.IsNoFill() )
03154 {
03155 a2dFill fillold = a2dCentralCanvasCommandProcessor::PROPID_Fill->GetPropertyValue( m_propObject );
03156 a2dCentralCanvasCommandProcessor::PROPID_Fill->SetPropertyToObject( m_propObject, m_fill );
03157 m_fill = fillold;
03158 }
03159 if ( !m_stroke.IsNoStroke() )
03160 {
03161 a2dStroke strokeold = a2dCentralCanvasCommandProcessor::PROPID_Stroke->GetPropertyValue( m_propObject );
03162 a2dCentralCanvasCommandProcessor::PROPID_Stroke->SetPropertyToObject( m_propObject, m_stroke );
03163 m_stroke = strokeold;
03164 }
03165
03166 return true;
03167 }
03168
03169 bool a2dCommand_ChangeCentralStyle::Undo(void)
03170 {
03171 return a2dCommand_ChangeCentralStyle::Do();
03172 }
03173
03174
03175
03176
03177
03178 const a2dCommandId a2dCommand_ChangeCanvasObjectStyle::sm_SetFillStyleCommand = a2dCommandId( wxT("SetCanvasObjectFillStyleCommand") );
03179 const a2dCommandId a2dCommand_ChangeCanvasObjectStyle::sm_SetStrokeStyleCommand = a2dCommandId( wxT("SetCanvasObjectStrokeStyleCommand") );
03180 const a2dCommandId a2dCommand_ChangeCanvasObjectStyle::sm_SetStyleCommand = a2dCommandId( wxT("SetCanvasObjectStyleCommand") );
03181
03182
03183
03184
03185 a2dCommand_ChangeCanvasObjectStyle::a2dCommand_ChangeCanvasObjectStyle( a2dPropObject* object, const a2dFill& fill ):
03186 a2dCommand( true, sm_SetFillStyleCommand, sm_SetStyleCommand )
03187 {
03188 m_fill = fill;
03189 m_stroke = *a2dNullSTROKE;
03190
03191 m_propObject = object;
03192 }
03193
03194 a2dCommand_ChangeCanvasObjectStyle::a2dCommand_ChangeCanvasObjectStyle( a2dPropObject* object, const a2dStroke& stroke ):
03195 a2dCommand( true, sm_SetStrokeStyleCommand, sm_SetStyleCommand )
03196 {
03197 m_fill = *a2dNullFILL;
03198 m_stroke = stroke;
03199
03200 m_propObject = object;
03201 }
03202
03203 a2dCommand_ChangeCanvasObjectStyle::a2dCommand_ChangeCanvasObjectStyle( a2dPropObject* object,
03204 const a2dFill& fill, const a2dStroke& stroke ):
03205 a2dCommand( true, sm_SetStyleCommand, sm_SetStyleCommand )
03206 {
03207 m_fill = fill;
03208 m_stroke = stroke;
03209
03210 m_propObject = object;
03211 }
03212
03213
03214 a2dCommand_ChangeCanvasObjectStyle::~a2dCommand_ChangeCanvasObjectStyle(void)
03215 {
03216 }
03217
03218 bool a2dCommand_ChangeCanvasObjectStyle::Do(void)
03219 {
03220 if ( !m_fill.IsNoFill() )
03221 {
03222 a2dFill fillold = a2dCanvasObject::PROPID_Fill->GetPropertyValue( m_propObject );
03223 a2dCanvasObject::PROPID_Fill->SetPropertyToObject( m_propObject, m_fill );
03224 m_fill = fillold;
03225 }
03226 if ( !m_stroke.IsNoStroke() )
03227 {
03228 a2dStroke strokeold = a2dCanvasObject::PROPID_Stroke->GetPropertyValue( m_propObject );
03229 a2dCanvasObject::PROPID_Stroke->SetPropertyToObject( m_propObject, m_stroke );
03230 m_stroke = strokeold;
03231 }
03232
03233 return true;
03234 }
03235
03236 bool a2dCommand_ChangeCanvasObjectStyle::Undo(void)
03237 {
03238 return a2dCommand_ChangeCanvasObjectStyle::Do();
03239 }
03240
03241
03242
03243
03244
03245 a2dCommand_SetCanvasProperty::a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdCanvasObject* id, a2dCanvasObject* value ):
03246 a2dCommand_SetProperty( object, id )
03247 {
03248 a2dCanvasObjectPtrProperty* prop = new a2dCanvasObjectPtrProperty( id, value );
03249
03250 m_property = prop;
03251 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
03252
03253 CurrentSmartPointerOwner = this;
03254 #endif
03255 }
03256
03257 a2dCommand_SetCanvasProperty::a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdMatrix* id, const a2dAffineMatrix& value ):
03258 a2dCommand_SetProperty( object, id )
03259 {
03260 a2dMatrixProperty* prop = new a2dMatrixProperty( id, value );
03261
03262 m_property = prop;
03263 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
03264
03265 CurrentSmartPointerOwner = this;
03266 #endif
03267 }
03268
03269 a2dCommand_SetCanvasProperty::a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdPoint2D* id, const a2dPoint2D& point, int index, bool afterinversion ):
03270 a2dCommand_SetProperty( object, id )
03271 {
03272 a2dPoint2DProperty* prop = new a2dPoint2DProperty( id, point, index, afterinversion );
03273
03274 m_property = prop;
03275 #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
03276
03277 CurrentSmartPointerOwner = this;
03278 #endif
03279 }
03280
03281 a2dCommand_SetCanvasProperty::a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdFill* id, const a2dFill& fill )
03282 {
03283 a2dFillProperty* prop = new a2dFillProperty( id, fill );
03284
03285 m_property = prop;
03286 }
03287
03288 a2dCommand_SetCanvasProperty::a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdStroke* id, const a2dStroke& stroke )
03289 {
03290 a2dStrokeProperty* prop = new a2dStrokeProperty( id, stroke );
03291
03292 m_property = prop;
03293 }
03294
03295 a2dCommand_SetCanvasProperty::~a2dCommand_SetCanvasProperty(void)
03296 {
03297 }
03298
03299 a2dCommand* a2dCommand_SetCanvasProperty::CloneAndBind( a2dPropObject *object )
03300 {
03301 wxASSERT( !m_propRefObject );
03302 return new a2dCommand_SetCanvasProperty( object, m_property->Clone( a2dObject::clone_flat ) );
03303 }
03304
03305 bool a2dCommand_SetCanvasProperty::Do(void)
03306 {
03307 bool ret = a2dCommand_SetProperty::Do();
03308
03309
03310 return ret;
03311 }
03312
03313 bool a2dCommand_SetCanvasProperty::Undo(void)
03314 {
03315 bool ret = a2dCommand_SetProperty::Undo();
03316
03317 return ret;
03318 }
03319
03320
03321
03322
03323
03324 a2dCommand_ConnectPins::a2dCommand_ConnectPins( a2dPin* pin1, a2dPin* pin2 )
03325 : a2dCommand( true, a2dCommand_ConnectPins::Id )
03326 {
03327 wxASSERT( pin1 );
03328
03329
03330 m_pin1 = pin1;
03331 m_pin2 = pin2;
03332 m_pin1oldtarget = 0;
03333 m_pin2oldtarget = 0;
03334 }
03335
03336 a2dCommand_ConnectPins::~a2dCommand_ConnectPins(void)
03337 {
03338 }
03339
03340 bool a2dCommand_ConnectPins::Do(void)
03341 {
03342 a2dPin *pin1 = wxStaticCast( m_pin1.Get(), a2dPin );
03343 a2dPin *pin2 = wxStaticCastNull( m_pin2.Get(), a2dPin );
03344
03345 m_pin1oldtarget = pin1->ConnectedTo();
03346 m_pin2oldtarget = pin2 ? pin2->ConnectedTo() : 0;
03347
03348 if( pin1->ConnectedTo() )
03349 {
03350 wxASSERT( pin1 == pin1->ConnectedTo()->ConnectedTo() );
03351 pin1->ConnectedTo()->ConnectTo( 0 );
03352 pin1->ConnectTo( 0 );
03353 }
03354
03355 if( pin2 && pin2->ConnectedTo() )
03356 {
03357 wxASSERT( pin2 == pin2->ConnectedTo()->ConnectedTo() );
03358 pin2->ConnectedTo()->ConnectTo( 0 );
03359 pin2->ConnectTo( 0 );
03360 }
03361
03362
03363 wxASSERT( !pin2 || pin1->MayConnectTo( pin2 ) );
03364 wxASSERT( !pin2 || pin2->MayConnectTo( pin1 ) );
03365
03366 pin1->ConnectTo( pin2 );
03367
03368 if( pin2 )
03369 pin2->ConnectTo( pin1 );
03370
03371 return true;
03372 }
03373
03374 bool a2dCommand_ConnectPins::Undo(void)
03375 {
03376 a2dPin *pin1 = wxStaticCast( m_pin1.Get(), a2dPin );
03377 a2dPin *pin2 = wxStaticCastNull( m_pin2.Get(), a2dPin );
03378 a2dPin *pin1oldtarget = wxStaticCastNull( m_pin1oldtarget.Get(), a2dPin );
03379 a2dPin *pin2oldtarget = wxStaticCastNull( m_pin2oldtarget.Get(), a2dPin );
03380
03381 pin1->ConnectTo( pin1oldtarget );
03382
03383 if( pin1oldtarget )
03384 {
03385
03386 wxASSERT( !pin1oldtarget->ConnectedTo() );
03387 pin1oldtarget->ConnectTo( pin1 );
03388 m_pin1oldtarget = 0;
03389 }
03390
03391 if( pin2 )
03392 {
03393 pin2->ConnectTo( pin2oldtarget );
03394
03395 if( pin2oldtarget )
03396 {
03397
03398 wxASSERT( !pin2oldtarget->ConnectedTo() );
03399 pin2oldtarget->ConnectTo( pin2 );
03400 m_pin2oldtarget = 0;
03401 }
03402 }
03403
03404 return true;
03405 }
03406
03407
03408
03409
03410
03411 bool a2dCommand_SetLayerMask::Do(void)
03412 {
03413 m_layer = m_layer == -1 ? a2dGetCmdh()->GetTarget(): m_layer;
03414 if ( m_layer > wxMAXLAYER )
03415 {
03416 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
03417 return false;
03418 }
03419
03420 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03421 if ( !doc )
03422 return false;
03423
03424 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03425 if ( !drawer )
03426 return false;
03427
03428 if ( ! m_parent )
03429 m_parent = drawer->GetShowObject();
03430
03431 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03432 m_objects = objects->Clone( m_mask, a2dObject::clone_flat );
03433
03434 if ( m_objects != wxNullCanvasObjectList )
03435 {
03436 forEachIn( a2dCanvasObjectList, m_objects )
03437 {
03438 a2dCanvasObject *obj = *iter;
03439 m_objectOldLayers.push_back( obj->GetLayer() );
03440 }
03441 }
03442 objects->ChangeLayer( m_layer, m_mask );
03443
03444 return true;
03445 }
03446
03447 bool a2dCommand_SetLayerMask::Undo(void)
03448 {
03449 if ( m_objects != wxNullCanvasObjectList )
03450 {
03451 a2dLayerGroup::iterator iterl = m_objectOldLayers.begin();
03452 while ( iterl != m_objectOldLayers.end() )
03453 {
03454 forEachIn( a2dCanvasObjectList, m_objects )
03455 {
03456 a2dCanvasObject *obj = *iter;
03457 obj->SetLayer( (*iterl) );
03458 iterl++;
03459 }
03460 }
03461 }
03462 m_objects->clear();
03463 return true;
03464 }
03465
03466
03467
03468
03469
03470 bool a2dCommand_DeleteMask::Do(void)
03471 {
03472 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03473 if ( !doc )
03474 return false;
03475
03476 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03477 if ( !drawer )
03478 return false;
03479
03480 if ( ! m_parent )
03481 m_parent = drawer->GetShowObject();
03482
03483 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03484 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
03485 for( a2dCanvasObjectList::iterator iter = m_objects->begin(); iter != m_objects->end(); ++iter )
03486 {
03487 a2dCanvasObject *obj = (*iter);
03488
03489 obj->ClearAllPinConnections( GetCanvasCmp() );
03490 }
03491 m_parent->ReleaseChildObjects(m_mask);
03492 return true;
03493 }
03494
03495 bool a2dCommand_DeleteMask::Undo(void)
03496 {
03497 if ( m_objects != wxNullCanvasObjectList )
03498 {
03499 a2dlist< long >::iterator index = m_objectsIndex.begin();
03500 while ( index != m_objectsIndex.end() )
03501 {
03502 forEachIn( a2dCanvasObjectList, m_objects )
03503 {
03504 a2dCanvasObject *obj = *iter;
03505 m_parent->Insert( *index, obj );
03506 index++;
03507 }
03508 }
03509 }
03510 m_objects->clear();
03511 return true;
03512 }
03513
03514
03515
03516
03517
03518 bool a2dCommand_ToTopMask::Do(void)
03519 {
03520 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03521 if ( !doc )
03522 return false;
03523
03524 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03525 if ( !drawer )
03526 return false;
03527
03528 if ( ! m_parent )
03529 m_parent = drawer->GetShowObject();
03530
03531 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03532 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
03533 if ( m_objects != wxNullCanvasObjectList )
03534 objects->BringToTop(m_mask);
03535 return true;
03536 }
03537
03538 bool a2dCommand_ToTopMask::Undo(void)
03539 {
03540 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03541 if ( m_objects != wxNullCanvasObjectList )
03542 {
03543 a2dlist< long >::iterator index = m_objectsIndex.begin();
03544 while ( index != m_objectsIndex.end() )
03545 {
03546 forEachIn( a2dCanvasObjectList, m_objects )
03547 {
03548 a2dCanvasObject *obj = *iter;
03549 objects->Release( obj, false, false, true );
03550 objects->Insert( *index, obj, true );
03551 index++;
03552 }
03553 }
03554 }
03555 m_objects->clear();
03556 return true;
03557 }
03558
03559
03560
03561
03562
03563 bool a2dCommand_ToBackMask::Do(void)
03564 {
03565 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03566 if ( !doc )
03567 return false;
03568
03569 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03570 if ( !drawer )
03571 return false;
03572
03573 if ( ! m_parent )
03574 m_parent = drawer->GetShowObject();
03575
03576 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03577 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
03578 if ( m_objects != wxNullCanvasObjectList )
03579 objects->BringToBack(m_mask);
03580 return true;
03581 }
03582
03583 bool a2dCommand_ToBackMask::Undo(void)
03584 {
03585 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03586 if ( m_objects != wxNullCanvasObjectList )
03587 {
03588 a2dlist< long >::iterator index = m_objectsIndex.begin();
03589 while ( index != m_objectsIndex.end() )
03590 {
03591 forEachIn( a2dCanvasObjectList, m_objects )
03592 {
03593 a2dCanvasObject *obj = *iter;
03594 objects->Release( obj, false, false, true );
03595 objects->Insert( *index, obj, true );
03596 index++;
03597 }
03598 }
03599 }
03600 m_objects->clear();
03601 return true;
03602 }
03603
03604
03605
03606
03607
03608 bool a2dCommand_CopyMask::Do(void)
03609 {
03610 m_target = m_target == -1 ? a2dGetCmdh()->GetTarget(): m_target;
03611 if ( m_target > wxMAXLAYER )
03612 {
03613 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
03614 return false;
03615 }
03616
03617 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03618 if ( !doc )
03619 return false;
03620
03621 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03622 if ( !drawer )
03623 return false;
03624
03625 if ( ! m_parent )
03626 m_parent = drawer->GetShowObject();
03627
03628 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03629
03630 if ( objects != wxNullCanvasObjectList )
03631 objects->Copy( m_x, m_y, m_mask, m_toTarget == false ? -1 : m_target, true );
03632
03633 m_objects = objects->CloneChecked( a2dObject::clone_flat );
03634 return true;
03635 }
03636
03637 bool a2dCommand_CopyMask::Undo(void)
03638 {
03639 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03640 if ( m_objects != wxNullCanvasObjectList )
03641 {
03642 forEachIn( a2dCanvasObjectList, m_objects )
03643 {
03644 a2dCanvasObject *obj = *iter;
03645
03646 objects->Release( obj, false, false, true );
03647 }
03648 }
03649 m_objects->clear();
03650 m_parent->SetPending( true );
03651 return true;
03652 }
03653
03654
03655
03656
03657
03658 bool a2dCommand_MoveMask::Do(void)
03659 {
03660 m_target = m_target == -1 ? a2dGetCmdh()->GetTarget(): m_target;
03661 if ( m_target > wxMAXLAYER )
03662 {
03663 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
03664 return false;
03665 }
03666
03667 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03668 if ( !doc )
03669 return false;
03670
03671 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03672 if ( !drawer )
03673 return false;
03674
03675 if ( ! m_parent )
03676 m_parent = drawer->GetShowObject();
03677
03678 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03679 m_objects = objects->Clone( m_mask, a2dObject::clone_flat );
03680
03681
03682
03683
03684
03685
03686
03687
03688
03689 if ( m_objects != wxNullCanvasObjectList )
03690 {
03691 forEachIn( a2dCanvasObjectList, m_objects )
03692 {
03693 a2dCanvasObject *obj = *iter;
03694 m_objectOldLayers.push_back( obj->GetLayer() );
03695 }
03696 objects->Move( m_x, m_y, m_mask, m_toTarget == false ? -1 : m_target );
03697 m_parent->SetPending( true );
03698 }
03699
03700 return true;
03701 }
03702
03703 bool a2dCommand_MoveMask::Undo(void)
03704 {
03705 if ( m_objects != wxNullCanvasObjectList )
03706 {
03707 a2dLayerGroup::iterator iterl = m_objectOldLayers.begin();
03708 while ( iterl != m_objectOldLayers.end() )
03709 {
03710 forEachIn( a2dCanvasObjectList, m_objects )
03711 {
03712 a2dCanvasObject *obj = *iter;
03713 obj->Translate( -m_x, -m_y );
03714 obj->SetLayer( (*iterl) );
03715 iterl++;
03716 }
03717 }
03718 }
03719 m_objects->clear();
03720 return true;
03721 }
03722
03723
03724
03725
03726
03727 bool a2dCommand_GroupMask::Do(void)
03728 {
03729 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03730 if ( !doc )
03731 return false;
03732
03733 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03734 if ( !drawer )
03735 return false;
03736
03737 if ( ! m_parent )
03738 m_parent = drawer->GetShowObject();
03739
03740 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03741 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
03742 if ( m_objects != wxNullCanvasObjectList )
03743 {
03744 m_groupobject = m_parent->CreateHierarchy(m_mask,false);
03745 if ( !m_name.IsEmpty() )
03746 m_groupobject->SetName( m_name );
03747 a2dWalker_SetSpecificFlagsCanvasObjects setflags( m_mask );
03748 setflags.Start( m_parent, false );
03749 m_parent->SetPending( true );
03750 }
03751 return true;
03752 }
03753
03754 bool a2dCommand_GroupMask::Undo(void)
03755 {
03756 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03757 if ( m_objects != wxNullCanvasObjectList )
03758 {
03759 objects->Release( m_groupobject, false, false, true );
03760 double x = m_groupobject->GetPosX();
03761 double y = m_groupobject->GetPosY();
03762
03763 a2dlist< long >::iterator index = m_objectsIndex.begin();
03764 while ( index != m_objectsIndex.end() )
03765 {
03766 forEachIn( a2dCanvasObjectList, m_objects )
03767 {
03768 a2dCanvasObject *obj = *iter;
03769 obj->Translate(x,y);
03770 objects->Insert( *index, obj, true );
03771 index++;
03772 }
03773 }
03774 }
03775 m_objects->clear();
03776 return true;
03777 }
03778
03779
03780
03781
03782
03783 bool a2dCommand_UnGroupMask::Do(void)
03784 {
03785 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03786 if ( !doc )
03787 return false;
03788
03789 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03790 if ( !drawer )
03791 return false;
03792
03793 if ( ! m_parent )
03794 m_parent = drawer->GetShowObject();
03795
03796 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03797 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
03798 if ( m_objects != wxNullCanvasObjectList )
03799 {
03800 a2dWalker_RemoveHierarchy remh( m_mask );
03801 if ( m_deep )
03802 remh.SetRecursionDepth( 20 );
03803 else
03804 remh.SetRecursionDepth( 1 );
03805 remh.Start( m_parent );
03806 m_parent->SetPending( true );
03807 }
03808 return true;
03809 }
03810
03811 bool a2dCommand_UnGroupMask::Undo(void)
03812 {
03813 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03814 if ( m_objects != wxNullCanvasObjectList )
03815 {
03816 a2dlist< long >::iterator index = m_objectsIndex.begin();
03817 while ( index != m_objectsIndex.end() )
03818 {
03819 forEachIn( a2dCanvasObjectList, m_objects )
03820 {
03821 a2dCanvasObject *obj = *iter;
03822 objects->Insert( *index, obj, true );
03823 index++;
03824 }
03825 }
03826 }
03827 m_objects->clear();
03828 return true;
03829 }
03830
03831
03832
03833
03834
03835 bool a2dCommand_MergeMask::Do(void)
03836 {
03837 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03838 if ( !doc )
03839 return false;
03840
03841 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03842 if ( !drawer )
03843 return false;
03844
03845 m_target = m_target == -1 ? a2dGetCmdh()->GetTarget(): m_target;
03846 if ( m_target > wxMAXLAYER )
03847 {
03848 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
03849 return false;
03850 }
03851
03852 if ( ! m_parent )
03853 m_parent = drawer->GetShowObject();
03854
03855 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03856 if ( m_clearorg )
03857 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
03858
03859 if ( m_objects != wxNullCanvasObjectList )
03860 {
03861 #if wxART2D_USE_KBOOL
03862 a2dBooleanWalkerHandler booloper( m_mask );
03863 booloper.SetReleaseOrignals( m_clearorg );
03864 booloper.SetClearTarget( false );
03865 a2dLayerGroup groupA;
03866 groupA.push_back( wxLAYER_ALL );
03867 booloper.SetGroupA( groupA );
03868 a2dLayerGroup groupB;
03869 booloper.SetGroupB( groupB );
03870 booloper.SetTarget( m_takeLayerFirstObject ? -1: m_target );
03871 booloper.SetRecursionDepth( m_depth );
03872 booloper.SetSelectedOnlyA( true );
03873 booloper.SetSelectedOnlyB( true );
03874
03875 double marge = a2dGetCmdh()->GetBooleanEngineMarge();
03876 booloper.SetMarge( marge/doc->GetUnitsScale() );
03877 booloper.SetGrid( a2dGetCmdh()->GetBooleanEngineGrid() );
03878 booloper.SetDGrid( a2dGetCmdh()->GetBooleanEngineDGrid() );
03879 booloper.SetCorrectionAber( double(a2dGetCmdh()->GetBooleanEngineCorrectionAber())/doc->GetUnitsScale() );
03880 booloper.SetCorrectionFactor( double(a2dGetCmdh()->GetBooleanEngineCorrectionFactor())/doc->GetUnitsScale() );
03881 booloper.SetMaxlinemerge( double(a2dGetCmdh()->GetBooleanEngineMaxlinemerge())/doc->GetUnitsScale() );
03882 booloper.SetWindingRule( a2dGetCmdh()->GetBooleanEngineWindingRule() );
03883 booloper.SetLinkHoles( a2dGetCmdh()->GetBooleanEngineLinkHoles() );
03884 booloper.SetRoundfactor( a2dGetCmdh()->GetBooleanEngineRoundfactor() );
03885
03886 booloper.SetOperation( a2dBooleanWalkerHandler::Boolean_OR );
03887 booloper.Start( m_parent );
03888
03889
03890 m_mergedObjects = objects->Clone( a2dCanvasOFlags::BIN2, a2dObject::clone_flat, NULL );
03891
03892 a2dWalker_SetSpecificFlagsCanvasObjects setflags( m_mask );
03893 setflags.Start( m_parent, false );
03894 m_parent->SetPending( true );
03895 #endif //wxART2D_USE_KBOOL
03896 }
03897 return true;
03898 }
03899
03900 bool a2dCommand_MergeMask::Undo(void)
03901 {
03902 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03903 if ( m_objects != wxNullCanvasObjectList )
03904 {
03905 a2dlist< long >::iterator index = m_objectsIndex.begin();
03906 while ( index != m_objectsIndex.end() )
03907 {
03908 forEachIn( a2dCanvasObjectList, m_objects )
03909 {
03910 a2dCanvasObject *obj = *iter;
03911 obj->SetRelease( false );
03912 objects->Insert( *index, obj, true );
03913 index++;
03914 }
03915 }
03916 m_objects->clear();
03917 }
03918 forEachIn( a2dCanvasObjectList, m_mergedObjects )
03919 {
03920 a2dCanvasObject *obj = *iter;
03921
03922 objects->Release( obj, false, false, true );
03923 }
03924 m_mergedObjects->clear();
03925 return true;
03926 }
03927
03928
03929
03930
03931
03932 bool a2dCommand_OffsetMask::Do(void)
03933 {
03934 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
03935 if ( !doc )
03936 return false;
03937
03938 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
03939 if ( !drawer )
03940 return false;
03941
03942 m_target = m_target == -1 ? a2dGetCmdh()->GetTarget(): m_target;
03943 if ( m_target > wxMAXLAYER )
03944 {
03945 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
03946 return false;
03947 }
03948
03949 if ( ! m_parent )
03950 m_parent = drawer->GetShowObject();
03951
03952 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
03953 if ( m_clearorg )
03954 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
03955
03956 if ( m_objects != wxNullCanvasObjectList )
03957 {
03958 #if wxART2D_USE_KBOOL
03959 a2dBooleanWalkerHandler booloper( m_mask );
03960 booloper.SetReleaseOrignals( m_clearorg );
03961 booloper.SetClearTarget( false );
03962 a2dLayerGroup groupA;
03963 groupA.push_back( wxLAYER_ALL );
03964 booloper.SetGroupA( groupA );
03965 a2dLayerGroup groupB;
03966 booloper.SetGroupB( groupB );
03967 booloper.SetTarget( m_takeLayerFirstObject ? -1: m_target );
03968 booloper.SetRecursionDepth( m_depth );
03969 booloper.SetSelectedOnlyA( true );
03970 booloper.SetSelectedOnlyB( true );
03971
03972 double marge = a2dGetCmdh()->GetBooleanEngineMarge();
03973 booloper.SetMarge( marge/doc->GetUnitsScale() );
03974 booloper.SetGrid( a2dGetCmdh()->GetBooleanEngineGrid() );
03975 booloper.SetDGrid( a2dGetCmdh()->GetBooleanEngineDGrid() );
03976 booloper.SetCorrectionAber( double(a2dGetCmdh()->GetBooleanEngineCorrectionAber())/doc->GetUnitsScale() );
03977 booloper.SetCorrectionFactor( double(a2dGetCmdh()->GetBooleanEngineCorrectionFactor())/doc->GetUnitsScale() );
03978 booloper.SetMaxlinemerge( double(a2dGetCmdh()->GetBooleanEngineMaxlinemerge())/doc->GetUnitsScale() );
03979 booloper.SetWindingRule( a2dGetCmdh()->GetBooleanEngineWindingRule() );
03980 booloper.SetLinkHoles( a2dGetCmdh()->GetBooleanEngineLinkHoles() );
03981 booloper.SetRoundfactor( a2dGetCmdh()->GetBooleanEngineRoundfactor() );
03982
03983 booloper.SetOperation( a2dBooleanWalkerHandler::Boolean_CORRECTION );
03984 booloper.Start( m_parent );
03985
03986
03987 m_offsetObjects = objects->Clone( a2dCanvasOFlags::BIN2, a2dObject::clone_flat, NULL );
03988
03989 a2dWalker_SetSpecificFlagsCanvasObjects setflags( m_mask );
03990 setflags.Start( m_parent, false );
03991 m_parent->SetPending( true );
03992 #endif //wxART2D_USE_KBOOL
03993 }
03994 return true;
03995 }
03996
03997 bool a2dCommand_OffsetMask::Undo(void)
03998 {
03999 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04000 if ( m_objects != wxNullCanvasObjectList )
04001 {
04002 a2dlist< long >::iterator index = m_objectsIndex.begin();
04003 while ( index != m_objectsIndex.end() )
04004 {
04005 forEachIn( a2dCanvasObjectList, m_objects )
04006 {
04007 a2dCanvasObject *obj = *iter;
04008 obj->SetRelease( false );
04009 objects->Insert( *index, obj, true );
04010 index++;
04011 }
04012 }
04013 m_objects->clear();
04014 }
04015 forEachIn( a2dCanvasObjectList, m_offsetObjects )
04016 {
04017 a2dCanvasObject *obj = *iter;
04018
04019 objects->Release( obj, false, false, true );
04020 }
04021 m_offsetObjects->clear();
04022 return true;
04023 }
04024
04025
04026
04027
04028
04029 bool a2dCommand_PolygonToSurfaceMask::Do(void)
04030 {
04031 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
04032 if ( !doc )
04033 return false;
04034
04035 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04036 if ( !drawer )
04037 return false;
04038
04039 m_target = m_target == -1 ? a2dGetCmdh()->GetTarget(): m_target;
04040 if ( m_target > wxMAXLAYER )
04041 {
04042 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
04043 return false;
04044 }
04045
04046 if ( ! m_parent )
04047 m_parent = drawer->GetShowObject();
04048
04049 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04050 if ( m_clearorg )
04051 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
04052
04053 if ( m_objects != wxNullCanvasObjectList )
04054 {
04055 #if wxART2D_USE_KBOOL
04056 a2dBooleanWalkerHandler booloper( m_mask );
04057 booloper.SetReleaseOrignals( m_clearorg );
04058 booloper.SetClearTarget( false );
04059 a2dLayerGroup groupA;
04060 groupA.push_back( wxLAYER_ALL );
04061 booloper.SetGroupA( groupA );
04062 a2dLayerGroup groupB;
04063 booloper.SetGroupB( groupB );
04064 booloper.SetTarget( m_takeLayerFirstObject ? -1: m_target );
04065 booloper.SetRecursionDepth( m_depth );
04066 booloper.SetSelectedOnlyA( true );
04067 booloper.SetSelectedOnlyB( true );
04068
04069 double marge = a2dGetCmdh()->GetBooleanEngineMarge();
04070 booloper.SetMarge( marge/doc->GetUnitsScale() );
04071 booloper.SetGrid( a2dGetCmdh()->GetBooleanEngineGrid() );
04072 booloper.SetDGrid( a2dGetCmdh()->GetBooleanEngineDGrid() );
04073 booloper.SetCorrectionAber( double(a2dGetCmdh()->GetBooleanEngineCorrectionAber())/doc->GetUnitsScale() );
04074 booloper.SetCorrectionFactor( double(a2dGetCmdh()->GetBooleanEngineCorrectionFactor())/doc->GetUnitsScale() );
04075 booloper.SetMaxlinemerge( double(a2dGetCmdh()->GetBooleanEngineMaxlinemerge())/doc->GetUnitsScale() );
04076 booloper.SetWindingRule( a2dGetCmdh()->GetBooleanEngineWindingRule() );
04077 booloper.SetLinkHoles( false );
04078 booloper.SetRoundfactor( a2dGetCmdh()->GetBooleanEngineRoundfactor() );
04079 booloper.SetOperation( a2dBooleanWalkerHandler::Boolean_Polygon2Surface );
04080
04081 booloper.Start( m_parent );
04082
04083
04084 m_offsetObjects = objects->Clone( a2dCanvasOFlags::BIN2, a2dObject::clone_flat, NULL );
04085
04086 a2dWalker_SetSpecificFlagsCanvasObjects setflags( m_mask );
04087 setflags.Start( m_parent, false );
04088 m_parent->SetPending( true );
04089 #endif //wxART2D_USE_KBOOL
04090 }
04091 return true;
04092 }
04093
04094 bool a2dCommand_PolygonToSurfaceMask::Undo(void)
04095 {
04096 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04097 if ( m_objects != wxNullCanvasObjectList )
04098 {
04099 a2dlist< long >::iterator index = m_objectsIndex.begin();
04100 while ( index != m_objectsIndex.end() )
04101 {
04102 forEachIn( a2dCanvasObjectList, m_objects )
04103 {
04104 a2dCanvasObject *obj = *iter;
04105 obj->SetRelease( false );
04106 objects->Insert( *index, obj, true );
04107 index++;
04108 }
04109 }
04110 m_objects->clear();
04111 }
04112 forEachIn( a2dCanvasObjectList, m_offsetObjects )
04113 {
04114 a2dCanvasObject *obj = *iter;
04115
04116 objects->Release( obj, false, false, true );
04117 }
04118 m_offsetObjects->clear();
04119 return true;
04120 }
04121
04122
04123
04124
04125
04126 bool a2dCommand_SurfaceToPolygonMask::Do(void)
04127 {
04128 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
04129 if ( !doc )
04130 return false;
04131
04132 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04133 if ( !drawer )
04134 return false;
04135
04136 m_target = m_target == -1 ? a2dGetCmdh()->GetTarget(): m_target;
04137 if ( m_target > wxMAXLAYER )
04138 {
04139 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
04140 return false;
04141 }
04142
04143 if ( ! m_parent )
04144 m_parent = drawer->GetShowObject();
04145
04146 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04147 if ( m_clearorg )
04148 m_objects = objects->Clone( m_mask, a2dObject::clone_flat, &m_objectsIndex );
04149
04150 if ( m_objects != wxNullCanvasObjectList )
04151 {
04152 #if wxART2D_USE_KBOOL
04153 a2dBooleanWalkerHandler booloper( m_mask );
04154 booloper.SetReleaseOrignals( m_clearorg );
04155 booloper.SetClearTarget( false );
04156 a2dLayerGroup groupA;
04157 groupA.push_back( wxLAYER_ALL );
04158 booloper.SetGroupA( groupA );
04159 a2dLayerGroup groupB;
04160 booloper.SetGroupB( groupB );
04161 booloper.SetTarget( m_takeLayerFirstObject ? -1: m_target );
04162 booloper.SetRecursionDepth( m_depth );
04163 booloper.SetSelectedOnlyA( true );
04164 booloper.SetSelectedOnlyB( true );
04165
04166 double marge = a2dGetCmdh()->GetBooleanEngineMarge();
04167 booloper.SetMarge( marge/doc->GetUnitsScale() );
04168 booloper.SetGrid( a2dGetCmdh()->GetBooleanEngineGrid() );
04169 booloper.SetDGrid( a2dGetCmdh()->GetBooleanEngineDGrid() );
04170 booloper.SetCorrectionAber( double(a2dGetCmdh()->GetBooleanEngineCorrectionAber())/doc->GetUnitsScale() );
04171 booloper.SetCorrectionFactor( double(a2dGetCmdh()->GetBooleanEngineCorrectionFactor())/doc->GetUnitsScale() );
04172 booloper.SetMaxlinemerge( double(a2dGetCmdh()->GetBooleanEngineMaxlinemerge())/doc->GetUnitsScale() );
04173 booloper.SetWindingRule( a2dGetCmdh()->GetBooleanEngineWindingRule() );
04174 booloper.SetLinkHoles( true );
04175 booloper.SetRoundfactor( a2dGetCmdh()->GetBooleanEngineRoundfactor() );
04176 booloper.SetOperation( a2dBooleanWalkerHandler::Boolean_Surface2Polygon );
04177
04178 booloper.Start( m_parent );
04179
04180
04181 m_offsetObjects = objects->Clone( a2dCanvasOFlags::BIN2, a2dObject::clone_flat, NULL );
04182
04183 a2dWalker_SetSpecificFlagsCanvasObjects setflags( m_mask );
04184 setflags.Start( m_parent, false );
04185 m_parent->SetPending( true );
04186 #endif //wxART2D_USE_KBOOL
04187 }
04188 return true;
04189 }
04190
04191 bool a2dCommand_SurfaceToPolygonMask::Undo(void)
04192 {
04193 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04194 if ( m_objects != wxNullCanvasObjectList )
04195 {
04196 a2dlist< long >::iterator index = m_objectsIndex.begin();
04197 while ( index != m_objectsIndex.end() )
04198 {
04199 forEachIn( a2dCanvasObjectList, m_objects )
04200 {
04201 a2dCanvasObject *obj = *iter;
04202 obj->SetRelease( false );
04203 objects->Insert( *index, obj, true );
04204 index++;
04205 }
04206 }
04207 m_objects->clear();
04208 }
04209 forEachIn( a2dCanvasObjectList, m_offsetObjects )
04210 {
04211 a2dCanvasObject *obj = *iter;
04212
04213 objects->Release( obj, false, false, true );
04214 }
04215 m_offsetObjects->clear();
04216 return true;
04217 }
04218
04219
04220
04221
04222
04223 bool a2dCommand_UrlOnMask::Do(void)
04224 {
04225 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
04226 if ( !doc )
04227 return false;
04228
04229 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04230 if ( !drawer )
04231 return false;
04232
04233 if ( ! m_parent )
04234 m_parent = drawer->GetShowObject();
04235
04236 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04237 m_oldobjects = objects->Clone( m_mask, a2dObject::clone_deep, &m_objectsIndex );
04238 m_objects = objects->Clone( m_mask, a2dObject::clone_flat );
04239
04240 if ( m_objects != wxNullCanvasObjectList )
04241 {
04242 for( a2dCanvasObjectList::iterator iter = m_objects->begin(); iter != m_objects->end(); iter++ )
04243 {
04244 PROPID_URL->SetPropertyToObject( (*iter), m_uri.BuildURI() );
04245 }
04246 }
04247
04248 return true;
04249 }
04250
04251 bool a2dCommand_UrlOnMask::Undo(void)
04252 {
04253 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04254 if ( m_oldobjects != wxNullCanvasObjectList )
04255 {
04256 a2dlist< long >::iterator index = m_objectsIndex.begin();
04257 while ( index != m_objectsIndex.end() )
04258 {
04259 forEachIn( a2dCanvasObjectList, m_objects )
04260 {
04261 a2dCanvasObject *obj = *iter;
04262 obj->SetRelease( false );
04263 objects->Insert( *index, obj, true );
04264 index++;
04265 }
04266 }
04267 m_oldobjects->clear();
04268 }
04269 forEachIn( a2dCanvasObjectList, m_objects )
04270 {
04271 a2dCanvasObject *obj = *iter;
04272
04273 objects->Release( obj, false, false, true );
04274 }
04275 m_objects->clear();
04276 return true;
04277 }
04278
04279
04280
04281
04282
04283 bool a2dCommand_SetFillStrokeMask::Do(void)
04284 {
04285 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
04286 if ( !doc )
04287 return false;
04288
04289 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04290 if ( !drawer )
04291 return false;
04292
04293 if ( ! m_parent )
04294 m_parent = drawer->GetShowObject();
04295
04296 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04297 m_oldobjects = objects->Clone( m_mask, a2dObject::clone_deep, &m_objectsIndex );
04298 m_objects = objects->Clone( m_mask, a2dObject::clone_flat );
04299
04300 if ( m_objects != wxNullCanvasObjectList )
04301 {
04302 m_objects->SetDrawerStyle( a2dGetCmdh()->GetFill(), a2dGetCmdh()->GetStroke(), m_mask);
04303 }
04304
04305 return true;
04306 }
04307
04308 bool a2dCommand_SetFillStrokeMask::Undo(void)
04309 {
04310 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04311 if ( m_oldobjects != wxNullCanvasObjectList )
04312 {
04313 a2dlist< long >::iterator index = m_objectsIndex.begin();
04314 while ( index != m_objectsIndex.end() )
04315 {
04316 forEachIn( a2dCanvasObjectList, m_objects )
04317 {
04318 a2dCanvasObject *obj = *iter;
04319 obj->SetRelease( false );
04320 objects->Insert( *index, obj, true );
04321 index++;
04322 }
04323 }
04324 m_oldobjects->clear();
04325 }
04326 forEachIn( a2dCanvasObjectList, m_objects )
04327 {
04328 a2dCanvasObject *obj = *iter;
04329
04330 objects->Release( obj, false, false, true );
04331 }
04332 m_objects->clear();
04333 return true;
04334 }
04335
04336
04337
04338
04339
04340 bool a2dCommand_ImagesToRectMask::Do(void)
04341 {
04342 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
04343 if ( !doc )
04344 return false;
04345
04346 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04347 if ( !drawer )
04348 return false;
04349
04350 if ( ! m_parent )
04351 m_parent = drawer->GetShowObject();
04352
04353 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04354 m_oldobjects = objects->Clone( m_mask, a2dObject::clone_deep, &m_objectsIndex );
04355 m_objects = objects->Clone( m_mask, a2dObject::clone_flat );
04356
04357 if ( m_objects != wxNullCanvasObjectList )
04358 {
04359 for( a2dCanvasObjectList::iterator iter = m_objects->begin(); iter != m_objects->end(); iter++ )
04360 {
04361 a2dImage* image = wxDynamicCast( (*iter).Get() , a2dImage );
04362 if ( image )
04363 {
04364 a2dCanvasObjectList* rectangles = image->GetAsRectangles( *wxBLACK, wxColour(173,173,175), true );
04365 objects->TakeOverFrom( rectangles );
04366 delete rectangles;
04367 }
04368 }
04369 }
04370
04371 return true;
04372 }
04373
04374 bool a2dCommand_ImagesToRectMask::Undo(void)
04375 {
04376 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04377 if ( m_oldobjects != wxNullCanvasObjectList )
04378 {
04379 a2dlist< long >::iterator index = m_objectsIndex.begin();
04380 while ( index != m_objectsIndex.end() )
04381 {
04382 forEachIn( a2dCanvasObjectList, m_objects )
04383 {
04384 a2dCanvasObject *obj = *iter;
04385 obj->SetRelease( false );
04386 objects->Insert( *index, obj, true );
04387 index++;
04388 }
04389 }
04390 m_oldobjects->clear();
04391 }
04392 forEachIn( a2dCanvasObjectList, m_objects )
04393 {
04394 a2dCanvasObject *obj = *iter;
04395
04396 objects->Release( obj, false, false, true );
04397 }
04398 m_objects->clear();
04399 return true;
04400 }
04401
04402
04403
04404
04405
04406 bool a2dCommand_SetLayersProperty::Do(void)
04407 {
04408 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
04409 if ( !doc )
04410 return false;
04411
04412 wxUint16 i = 0;
04413 for ( i = 0; i < doc->GetLayerSetup()->GetChildObjectsCount(); i++)
04414 {
04415 a2dLayerInfo* layerinfo = doc->GetLayerSetup()->GetLayerIndex()[i];
04416 m_oldLayersVisible.push_back( layerinfo->GetVisible() );
04417 if ( layerinfo != wxNullLayerInfo )
04418 {
04419 switch ( m_setWhat )
04420 {
04421 case visible:
04422 layerinfo->SetVisible( m_value );
04423 break;
04424 case selectable:
04425 layerinfo->SetSelectable( m_value );
04426 break;
04427 case readable:
04428 layerinfo->SetRead( m_value );
04429 break;
04430 case filling:
04431 {
04432 a2dFill fill = layerinfo->GetFill();
04433 fill.SetFilling( m_value );
04434 layerinfo->SetFill( fill );
04435 }
04436 break;
04437 }
04438 }
04439 }
04440 return true;
04441 }
04442
04443 bool a2dCommand_SetLayersProperty::Undo(void)
04444 {
04445 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
04446 if ( !doc )
04447 return false;
04448
04449 wxUint16 layer = 0;
04450 a2dlist< bool >::iterator index = m_oldLayersVisible.begin();
04451 while ( index != m_oldLayersVisible.end() )
04452 {
04453 bool value = *index;
04454 a2dLayerInfo* layerinfo = doc->GetLayerSetup()->GetLayerIndex()[layer];
04455 if ( layerinfo != wxNullLayerInfo )
04456 {
04457 switch ( m_setWhat )
04458 {
04459 case visible:
04460 layerinfo->SetVisible( value );
04461 break;
04462 case selectable:
04463 layerinfo->SetSelectable( value );
04464 break;
04465 case readable:
04466 layerinfo->SetRead( value );
04467 break;
04468 }
04469 }
04470 }
04471 return true;
04472 }
04473
04474 void a2dCommand_SetLayersProperty::DistributeEvent( wxEventType eventType )
04475 {
04476 a2dCommand::DistributeEvent( eventType );
04477
04478 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
04479 if ( !doc )
04480 return;
04481 a2dComEvent changedlayer( doc, doc->GetLayerSetup(), &a2dCanvasDocument::sm_layersetupChanged );
04482 a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedlayer );
04483 }
04484
04485
04486 bool a2dCommand_Select::Do()
04487 {
04488 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
04489 if ( !doc )
04490 return false;
04491
04492 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04493 if ( !drawer )
04494 return false;
04495
04496 if ( ! m_parent )
04497 m_parent = drawer->GetShowObject();
04498
04499 if ( m_args.argValue.what == SelectRect )
04500 {
04501 a2dBoundingBox bbox = a2dBoundingBox( m_args.argValue.x1, m_args.argValue.y1, m_args.argValue.x2, m_args.argValue.y2 );
04502 if ( m_parent->GetChildObjectList() != wxNullCanvasObjectList )
04503 {
04504 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04505 m_oldobjects = new a2dCanvasObjectList();
04506
04507 forEachIn( a2dCanvasObjectList, objects )
04508 {
04509 a2dCanvasObject *obj = *iter;
04510 if ( obj->GetRelease() || !obj->IsVisible() || obj->GetSelected() )
04511 continue;
04512 if ( bbox.GetValid() )
04513 {
04514 a2dBoundingBox tmp;
04515 tmp.Expand( obj->GetBbox() );
04516 if (bbox.Intersect(tmp) != _IN )
04517 continue;
04518 }
04519
04520 if ( m_args.argValue.layervisible && m_args.argValue.layerselectable && obj->GetCanvasDocument() && obj->GetCanvasDocument()->GetLayerSetup() )
04521 {
04522 if ( m_args.argValue.layervisible && !obj->GetCanvasDocument()->GetLayerSetup()->GetVisible( obj->GetLayer() ) )
04523 continue;
04524 if ( m_args.argValue.layerselectable && !obj->GetCanvasDocument()->GetLayerSetup()->GetSelectable( obj->GetLayer() ) )
04525 continue;
04526 }
04527 if ( !m_args.argSet.layer || (m_args.argSet.layer && obj->GetLayer() == m_args.argValue.layer) )
04528 {
04529 m_oldobjectsSelected.push_back( obj->GetSelected() );
04530 obj->SetSelected( true );
04531 m_oldobjects->push_back( obj );
04532 }
04533 }
04534 }
04535 return true;
04536 }
04537 else if ( m_args.argValue.what == DeSelectRect )
04538 {
04539 a2dBoundingBox bbox = a2dBoundingBox( m_args.argValue.x1, m_args.argValue.y1, m_args.argValue.x2, m_args.argValue.y2 );
04540 if ( m_parent->GetChildObjectList() != wxNullCanvasObjectList )
04541 {
04542 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04543 m_oldobjects = new a2dCanvasObjectList();
04544
04545 forEachIn( a2dCanvasObjectList, objects )
04546 {
04547 a2dCanvasObject *obj = *iter;
04548 if ( obj->GetRelease() || !obj->IsVisible() || !obj->GetSelected() )
04549 continue;
04550 if ( bbox.GetValid() )
04551 {
04552 a2dBoundingBox tmp;
04553 tmp.Expand( obj->GetBbox() );
04554 if (bbox.Intersect(tmp) != _IN )
04555 continue;
04556 }
04557
04558 if ( m_args.argValue.layervisible && m_args.argValue.layerselectable && obj->GetCanvasDocument() && obj->GetCanvasDocument()->GetLayerSetup() )
04559 {
04560 if ( m_args.argValue.layervisible && !obj->GetCanvasDocument()->GetLayerSetup()->GetVisible( obj->GetLayer() ) )
04561 continue;
04562 if ( m_args.argValue.layerselectable && !obj->GetCanvasDocument()->GetLayerSetup()->GetSelectable( obj->GetLayer() ) )
04563 continue;
04564 }
04565 if ( !m_args.argSet.layer || (m_args.argSet.layer && obj->GetLayer() == m_args.argValue.layer) )
04566 {
04567 m_oldobjectsSelected.push_back( obj->GetSelected() );
04568 obj->SetSelected( false );
04569 m_oldobjects->push_back( obj );
04570 }
04571 }
04572 }
04573 return true;
04574 }
04575 else if ( m_args.argValue.what == SelectAll )
04576 {
04577 if ( m_parent->GetChildObjectList() != wxNullCanvasObjectList )
04578 {
04579 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04580 m_oldobjects = new a2dCanvasObjectList();
04581 forEachIn( a2dCanvasObjectList, objects )
04582 {
04583 a2dCanvasObject *obj = *iter;
04584 if ( obj->GetRelease() || !obj->IsVisible() || obj->GetSelected() )
04585 continue;
04586 if ( m_args.argValue.layervisible && m_args.argValue.layerselectable && obj->GetCanvasDocument() && obj->GetCanvasDocument()->GetLayerSetup() )
04587 {
04588 if ( m_args.argValue.layervisible && !obj->GetCanvasDocument()->GetLayerSetup()->GetVisible( obj->GetLayer() ) )
04589 continue;
04590 if ( m_args.argValue.layerselectable && !obj->GetCanvasDocument()->GetLayerSetup()->GetSelectable( obj->GetLayer() ) )
04591 continue;
04592 }
04593 if ( !m_args.argSet.layer || (m_args.argSet.layer && obj->GetLayer() == m_args.argValue.layer) )
04594 {
04595 m_oldobjectsSelected.push_back( obj->GetSelected() );
04596 obj->SetSelected( true );
04597 m_oldobjects->push_back( obj );
04598 }
04599 }
04600 drawer->GetDisplayWindow()->Refresh();
04601 }
04602 return true;
04603 }
04604 else if ( m_args.argValue.what == DeSelectAll )
04605 {
04606 m_parent->SetSpecificFlags( false, a2dCanvasOFlags::SELECTED );
04607 if ( m_parent->GetChildObjectList() != wxNullCanvasObjectList )
04608 {
04609 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04610 m_oldobjects = new a2dCanvasObjectList();
04611 forEachIn( a2dCanvasObjectList, objects )
04612 {
04613 a2dCanvasObject *obj = *iter;
04614 if ( obj->GetRelease() || !obj->IsVisible() || !obj->GetSelected() )
04615 continue;
04616 if ( m_args.argValue.layervisible && m_args.argValue.layerselectable && obj->GetCanvasDocument() && obj->GetCanvasDocument()->GetLayerSetup() )
04617 {
04618 if ( m_args.argValue.layervisible && !obj->GetCanvasDocument()->GetLayerSetup()->GetVisible( obj->GetLayer() ) )
04619 continue;
04620 if ( m_args.argValue.layerselectable && !obj->GetCanvasDocument()->GetLayerSetup()->GetSelectable( obj->GetLayer() ) )
04621 continue;
04622 }
04623 if ( !m_args.argSet.layer || (m_args.argSet.layer && obj->GetLayer() == m_args.argValue.layer) )
04624 {
04625 m_oldobjectsSelected.push_back( obj->GetSelected() );
04626 obj->SetSelected( false );
04627 m_oldobjects->push_back( obj );
04628 }
04629 }
04630 drawer->GetDisplayWindow()->Refresh();
04631 }
04632 return true;
04633 }
04634 return false;
04635 }
04636
04637 bool a2dCommand_Select::Undo()
04638 {
04639 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
04640 if ( !doc )
04641 return false;
04642
04643 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04644 if ( !drawer )
04645 return false;
04646
04647 if ( ! m_parent )
04648 m_parent = drawer->GetShowObject();
04649
04650 if ( m_args.argValue.what == SelectRect )
04651 {
04652 if ( m_oldobjects != wxNullCanvasObjectList )
04653 {
04654 a2dlist< bool >::iterator selectState = m_oldobjectsSelected.begin();
04655 forEachIn( a2dCanvasObjectList, m_oldobjects )
04656 {
04657 a2dCanvasObject *obj = *iter;
04658 obj->SetSelected( *selectState );
04659 selectState++;
04660 }
04661 drawer->GetDisplayWindow()->Refresh();
04662 }
04663 return true;
04664 }
04665 else if ( m_args.argValue.what == DeSelectRect )
04666 {
04667 if ( m_oldobjects != wxNullCanvasObjectList )
04668 {
04669 a2dlist< bool >::iterator selectState = m_oldobjectsSelected.begin();
04670 forEachIn( a2dCanvasObjectList, m_oldobjects )
04671 {
04672 a2dCanvasObject *obj = *iter;
04673 obj->SetSelected( *selectState );
04674 selectState++;
04675 }
04676 drawer->GetDisplayWindow()->Refresh();
04677 }
04678 return true;
04679 }
04680 else if ( m_args.argValue.what == SelectAll )
04681 {
04682 if ( m_oldobjects != wxNullCanvasObjectList )
04683 {
04684 a2dCanvasObjectList* objects = m_parent->GetChildObjectList();
04685 objects->SetSpecificFlags( false, a2dCanvasOFlags::SELECTED );
04686 a2dlist< bool >::iterator selectState = m_oldobjectsSelected.begin();
04687 forEachIn( a2dCanvasObjectList, m_oldobjects )
04688 {
04689 a2dCanvasObject *obj = *iter;
04690 obj->SetSelected( *selectState );
04691 selectState++;
04692 }
04693 drawer->GetDisplayWindow()->Refresh();
04694 }
04695 return true;
04696 }
04697 else if ( m_args.argValue.what == DeSelectAll )
04698 {
04699 if ( m_oldobjects != wxNullCanvasObjectList )
04700 {
04701 a2dlist< bool >::iterator selectState = m_oldobjectsSelected.begin();
04702 forEachIn( a2dCanvasObjectList, m_oldobjects )
04703 {
04704 a2dCanvasObject *obj = *iter;
04705 obj->SetSelected( *selectState );
04706 selectState++;
04707 }
04708 drawer->GetDisplayWindow()->Refresh();
04709 }
04710 return true;
04711 }
04712 return false;
04713 }
04714
04715
04716
04717
04718
04719 bool a2dCommand_ConvertMask::Do(void)
04720 {
04721 m_args.argValue.target = m_args.argValue.target == -1 ? a2dGetCmdh()->GetTarget(): m_args.argValue.target;
04722 a2dCanvasObjectPtr parent = m_args.argValue.parent;
04723 if ( m_args.argValue.target > wxMAXLAYER )
04724 {
04725 (void)wxMessageBox( _("Target Layer is not available"), _("Layers"), wxICON_INFORMATION | wxOK );
04726 return false;
04727 }
04728
04729 a2dCanvasDocument* doc = a2dGetCmdh()->CheckCanvasDocument();
04730 if ( !doc )
04731 return false;
04732
04733 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
04734 if ( !drawer )
04735 return false;
04736
04737 if ( ! parent )
04738 parent = drawer->GetShowObject();
04739
04740 double radiusMin = double( a2dGetCmdh()->GetRadiusMin())/doc->GetUnitsScale();
04741 double radiusMax = double( a2dGetCmdh()->GetRadiusMax())/doc->GetUnitsScale();
04742 double AberPolyToArc = double( a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale();
04743
04744 a2dCanvasObjectList* objects = parent->GetChildObjectList();
04745
04746 m_maskobjects = objects->Clone( m_args.argValue.mask, a2dObject::clone_flat, &m_objectsIndex );
04747 if ( m_args.argValue.deleteOriginal )
04748 {
04749 for( a2dCanvasObjectList::iterator iter = m_maskobjects->begin(); iter != m_maskobjects->end(); ++iter )
04750 {
04751 a2dCanvasObject *obj = (*iter);
04752
04753 obj->ClearAllPinConnections( GetCanvasCmp() );
04754 }
04755 parent->ReleaseChildObjects(m_args.argValue.mask);
04756 }
04757
04758 if ( m_maskobjects != wxNullCanvasObjectList )
04759 {
04760 m_newobjects = new a2dCanvasObjectList();
04761
04762 long destLayer = m_args.argValue.target;
04763 forEachIn( a2dCanvasObjectList, m_maskobjects )
04764 {
04765 a2dCanvasObject *obj = *iter;
04766 if ( m_args.argValue.keepLayer )
04767 destLayer = obj->GetLayer();
04768
04769 if ( m_args.argValue.what == ConvertPolygonToArcs )
04770 {
04771 if (0 != wxDynamicCast( obj, a2dPolylineL ) && obj->GetContourWidth() )
04772 {
04773 a2dPolylineL* objc = wxDynamicCast( obj, a2dPolylineL );
04774 a2dPolygonL* contour = objc->GetAsPolygon();
04775 contour->SetLayer( destLayer );
04776 contour->SetBin( true );
04777 contour->GetSegments()->ConvertPolylineToArc( AberPolyToArc, radiusMin, radiusMax );
04778 parent->Append( contour );
04779 m_newobjects->push_back( contour );
04780 }
04781 else if (0 != wxDynamicCast( obj, a2dPolygonL ))
04782 {
04783 a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
04784 cobj->SetLayer( destLayer );
04785 cobj->SetBin( true );
04786 parent->Append( cobj );
04787 m_newobjects->push_back( cobj );
04788 a2dPolygonL* objc = wxDynamicCast( cobj, a2dPolygonL );
04789 objc->GetSegments()->ConvertPolygonToArc( AberPolyToArc, radiusMin, radiusMax );
04790 }
04791 }
04792 if ( m_args.argValue.what == ConvertPolylineToArcs )
04793 {
04794 if (0 != wxDynamicCast( obj, a2dPolylineL ) && obj->GetContourWidth() )
04795 {
04796 a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
04797 a2dPolylineL* objc = wxDynamicCast( cobj, a2dPolylineL );
04798 cobj->SetLayer( destLayer );
04799 cobj->SetBin( true );
04800 parent->Append( cobj );
04801 m_newobjects->push_back( cobj );
04802 objc->GetSegments()->ConvertPolylineToArc( AberPolyToArc, radiusMin, radiusMax );
04803 }
04804 else if (0 != wxDynamicCast( obj, a2dPolylineL ) )
04805 {
04806 a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
04807 cobj->SetLayer( destLayer );
04808 cobj->SetBin( true );
04809 parent->Append( cobj );
04810 m_newobjects->push_back( cobj );
04811 a2dPolylineL* objc = wxDynamicCast( cobj, a2dPolylineL );
04812 objc->GetSegments()->ConvertPolylineToArc( AberPolyToArc, radiusMin, radiusMax );
04813 }
04814 }
04815 if ( m_args.argValue.what == ConvertToPolygonPolylinesWithArcs )
04816 {
04817 a2dCanvasObjectList* polylist = GetCanvasCmp()->ConvertToPolygons( obj, true );
04818 for( a2dCanvasObjectList::iterator iterp = polylist->begin(); iterp != polylist->end(); ++iterp )
04819 {
04820 a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
04821 a2dPolylineL* polyline = wxDynamicCast( (*iterp).Get(), a2dPolylineL );
04822 if ( polyline && polyline->GetNumberOfSegments() > 2 )
04823 {
04824 polyline->SetLayer( destLayer );
04825 polyline->SetBin( true );
04826 parent->Append( polyline );
04827 m_newobjects->push_back( polyline );
04828 }
04829 else if ( poly && poly->GetNumberOfSegments() > 2 )
04830 {
04831 poly->SetLayer( destLayer );
04832 poly->SetBin( true );
04833 parent->Append( poly );
04834 m_newobjects->push_back( poly );
04835 }
04836 }
04837 delete polylist;
04838 }
04839 if ( m_args.argValue.what == ConvertToPolygonPolylinesWithoutArcs )
04840 {
04841 a2dCanvasObjectList* polylist = GetCanvasCmp()->ConvertToPolygons( obj, true );
04842 for( a2dCanvasObjectList::iterator iterp = polylist->begin(); iterp != polylist->end(); ++iterp )
04843 {
04844
04845 a2dSmrtPtr<a2dPolylineL> polyline = wxDynamicCast( (*iterp).Get(), a2dPolylineL );
04846 if ( polyline )
04847 {
04848 a2dSmrtPtr<a2dPolygonL> poly = polyline->GetAsPolygon();
04849 if ( poly && poly->GetSegments()->HasArcs() )
04850 poly->GetSegments()->ConvertToLines();
04851
04852 if ( poly )
04853 {
04854 if ( poly->GetNumberOfSegments() > 2 )
04855 {
04856 poly->SetLayer( destLayer );
04857 poly->SetBin( true );
04858 poly->GetSegments()->ConvertToLines();
04859 parent->Append( poly );
04860 m_newobjects->push_back( poly.Get() );
04861 }
04862 else
04863 {
04864 polyline->SetLayer( destLayer );
04865 polyline->SetBin( true );
04866 polyline->GetSegments()->ConvertToLines();
04867 parent->Append( polyline );
04868 m_newobjects->push_back( polyline.Get() );
04869 }
04870 }
04871 else
04872 {
04873 polyline->SetLayer( destLayer );
04874 polyline->SetBin( true );
04875 polyline->GetSegments()->ConvertToLines();
04876 parent->Append( polyline );
04877 m_newobjects->push_back( polyline.Get() );
04878 }
04879 }
04880 else
04881 {
04882 a2dSmrtPtr<a2dPolygonL> poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
04883 if ( poly && poly->GetSegments()->HasArcs() )
04884 poly->GetSegments()->ConvertToLines();
04885
04886 if ( poly && poly->GetNumberOfSegments() > 2 )
04887 {
04888 poly->SetLayer( destLayer );
04889 poly->SetBin( true );
04890 poly->GetSegments()->ConvertToLines();
04891 parent->Append( poly );
04892 m_newobjects->push_back( poly.Get() );
04893 }
04894 }
04895 }
04896 delete polylist;
04897 }
04898 if ( m_args.argValue.what == ConvertToVPaths )
04899 {
04900 a2dCanvasObjectList* vpath = GetCanvasCmp()->ConvertToVpath( obj, true );
04901 for( a2dCanvasObjectList::iterator iterp = vpath->begin(); iterp != vpath->end(); ++iterp )
04902 {
04903 a2dVectorPath* path = wxDynamicCast( (*iterp).Get(), a2dVectorPath );
04904 path->SetLayer( destLayer );
04905 path->SetBin( true );
04906 parent->Append( path );
04907 m_newobjects->push_back( path );
04908 }
04909 delete vpath;
04910 }
04911 if ( m_args.argValue.what == ConvertToPolylines )
04912 {
04913 a2dCanvasObjectList* polylist = GetCanvasCmp()->ConvertToPolygons( obj, true );
04914 int i, count = polylist->size();
04915 a2dCanvasObjectList::iterator iterp = polylist->begin();
04916 for( i = 0 ; i < count ; i++ )
04917 {
04918 a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
04919 a2dPolylineL* polyline = wxDynamicCast( (*iterp).Get(), a2dPolylineL );
04920 if ( polyline && polyline->GetNumberOfSegments() > 2 )
04921 {
04922 polyline->SetLayer( destLayer );
04923 polyline->SetBin( true );
04924 parent->Append( polyline );
04925 m_newobjects->push_back( polyline );
04926 iterp++;
04927 }
04928 else if ( poly && poly->GetNumberOfSegments() > 2 )
04929 {
04930 a2dPolylineL* conv = new a2dPolylineL( poly->GetSegments() );
04931
04932 poly->SetLayer( destLayer );
04933 poly->SetBin( true );
04934 parent->Append( conv );
04935 m_newobjects->push_back( conv );
04936 iterp = polylist->erase( iterp );
04937 }
04938 }
04939 delete polylist;
04940 }
04941 if ( m_args.argValue.what == ConvertLinesArcs )
04942 {
04943 a2dCanvasObjectList* polylist = GetCanvasCmp()->ConvertToPolygons( obj, true );
04944 int i, count = polylist->size();
04945 a2dCanvasObjectList::iterator iterp = polylist->begin();
04946 for( i = 0 ; i < count ; i++ )
04947 {
04948 a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
04949 poly->SetLayer( destLayer );
04950 poly->SetBin(true );
04951 a2dCanvasObjectList* linesAndArcs = poly->GetAsLinesArcs();
04952 forEachIn( a2dCanvasObjectList, linesAndArcs )
04953 {
04954 a2dCanvasObject *obj = *iter;
04955 parent->Append( obj );
04956 }
04957 m_newobjects->TakeOverFrom( linesAndArcs );
04958 iterp = polylist->erase( iterp );
04959 delete linesAndArcs;
04960 }
04961 delete polylist;
04962 }
04963 }
04964 parent->SetCanvasDocument( doc );
04965 parent->SetPending( true );
04966 }
04967
04968 return true;
04969 }
04970
04971 bool a2dCommand_ConvertMask::Undo(void)
04972 {
04973 if ( m_args.argValue.deleteOriginal && m_maskobjects != wxNullCanvasObjectList )
04974 {
04975 a2dlist< long >::iterator index = m_objectsIndex.begin();
04976 while ( index != m_objectsIndex.end() )
04977 {
04978 forEachIn( a2dCanvasObjectList, m_maskobjects )
04979 {
04980 a2dCanvasObject *obj = *iter;
04981 m_args.argValue.parent->Insert( *index, obj );
04982 index++;
04983 }
04984 }
04985 }
04986 m_maskobjects->clear();
04987
04988 a2dCanvasObjectList* objects = m_args.argValue.parent->GetChildObjectList();
04989 if ( m_newobjects != wxNullCanvasObjectList )
04990 {
04991 forEachIn( a2dCanvasObjectList, m_newobjects )
04992 {
04993 a2dCanvasObject *obj = *iter;
04994
04995 objects->Release( obj, false, false, true );
04996 }
04997 }
04998 m_newobjects->clear();
04999 m_args.argValue.parent->SetPending( true );
05000 return true;
05001 }
05002
05003
05004
05005
05006
05007 bool a2dCommand_GroupAB::Do()
05008 {
05009 m_args.argValue.target = m_args.argSet.target ? m_args.argValue.target : a2dGetCmdh()->GetTarget();
05010 m_args.argValue.clearTarget = m_args.argSet.clearTarget ? m_args.argValue.clearTarget : a2dGetCmdh()->GetClearTarget();
05011 m_args.argValue.selectedA = m_args.argSet.selectedA ? m_args.argValue.selectedA : a2dGetCmdh()->GetSelectedOnlyA();
05012 m_args.argValue.selectedB = m_args.argSet.selectedB ? m_args.argValue.selectedB : a2dGetCmdh()->GetSelectedOnlyB();
05013
05014 a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
05015 if ( !doc )
05016 return false;
05017
05018 a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
05019 if ( !drawer )
05020 return false;
05021
05022 if ( m_args.argValue.what == ConvertToArcs )
05023 {
05024 a2dWalker_LayerCanvasObjects ConvertToArcs;
05025 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05026 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertToArcs );
05027 ConvertToArcs.SetRadiusMin( double(a2dGetCmdh()->GetRadiusMin())/doc->GetUnitsScale() );
05028 ConvertToArcs.SetRadiusMax( double(a2dGetCmdh()->GetRadiusMax())/doc->GetUnitsScale() );
05029 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05030 ConvertToArcs.SetTarget( m_args.argValue.target );
05031 ConvertToArcs.SetDetectCircle( m_args.argValue.detectCircle );
05032 ConvertToArcs.Start( drawer->GetShowObject() );
05033 }
05034 if ( m_args.argValue.what == ConvertToPolygonPolylinesWithArcs )
05035 {
05036 a2dWalker_LayerCanvasObjects ConvertToArcs;
05037 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05038 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertToPolygonPolylinesWithArcs );
05039 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05040 ConvertToArcs.SetTarget( m_args.argValue.target );
05041 ConvertToArcs.Start( drawer->GetShowObject() );
05042 }
05043 if ( m_args.argValue.what == ConvertToPolygonPolylinesWithoutArcs )
05044 {
05045 a2dWalker_LayerCanvasObjects ConvertToArcs;
05046 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05047 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertToPolygonPolylinesWithArcs );
05048 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05049 ConvertToArcs.SetTarget( m_args.argValue.target );
05050 ConvertToArcs.Start( drawer->GetShowObject() );
05051 }
05052 if ( m_args.argValue.what == ConvertPolygonToArcs )
05053 {
05054 a2dWalker_LayerCanvasObjects ConvertToArcs;
05055 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05056 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertPolygonToArcs );
05057 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05058 ConvertToArcs.SetTarget( m_args.argValue.target );
05059 ConvertToArcs.SetDetectCircle( m_args.argValue.detectCircle );
05060 ConvertToArcs.Start( drawer->GetShowObject() );
05061 }
05062 if ( m_args.argValue.what == ConvertPolylineToArcs )
05063 {
05064 a2dWalker_LayerCanvasObjects ConvertToArcs;
05065 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05066 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertPolylineToArcs );
05067 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05068 ConvertToArcs.SetTarget( m_args.argValue.target );
05069 ConvertToArcs.SetDetectCircle( m_args.argValue.detectCircle );
05070 ConvertToArcs.Start( drawer->GetShowObject() );
05071 }
05072 if ( m_args.argValue.what == ConvertLinesArcs )
05073 {
05074 a2dWalker_LayerCanvasObjects ConvertToArcs;
05075 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05076 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertLinesArcs );
05077 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05078 ConvertToArcs.SetTarget( m_args.argValue.target );
05079
05080 ConvertToArcs.Start( drawer->GetShowObject() );
05081 }
05082 if ( m_args.argValue.what == ConvertToPolylines )
05083 {
05084 a2dWalker_LayerCanvasObjects ConvertToArcs;
05085 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05086 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertToPolylines );
05087 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05088 ConvertToArcs.SetTarget( m_args.argValue.target );
05089
05090 ConvertToArcs.Start( drawer->GetShowObject() );
05091 }
05092 if ( m_args.argValue.what == ConvertToVPaths )
05093 {
05094 a2dWalker_LayerCanvasObjects ConvertToArcs;
05095 ConvertToArcs.SetGroupA( a2dGetCmdh()->GetGroupA() );
05096 ConvertToArcs.SetOperation( a2dWalker_LayerCanvasObjects::ConvertToVPaths );
05097 ConvertToArcs.SetAberPolyToArc( double(a2dGetCmdh()->GetAberPolyToArc())/doc->GetUnitsScale() );
05098 ConvertToArcs.SetTarget( m_args.argValue.target );
05099
05100 ConvertToArcs.Start( drawer->GetShowObject() );
05101 }
05102 if ( m_args.argValue.what == DeleteGroupA )
05103 {
05104 a2dWalker_LayerCanvasObjects deleteLayer;
05105 deleteLayer.SetGroupA( a2dGetCmdh()->GetGroupA() );
05106 deleteLayer.SetOperation( a2dWalker_LayerCanvasObjects::deleteLayers );
05107
05108 deleteLayer.Start( drawer->GetShowObject() );
05109 }
05110 if ( m_args.argValue.what == MoveGroupA )
05111 {
05112 a2dWalker_LayerCanvasObjects moveLayer;
05113 moveLayer.SetGroupA( a2dGetCmdh()->GetGroupA() );
05114 moveLayer.SetOperation( a2dWalker_LayerCanvasObjects::moveLayers );
05115 moveLayer.SetTarget( m_args.argValue.target );
05116
05117 moveLayer.Start( drawer->GetShowObject() );
05118 }
05119 if ( m_args.argValue.what == CopyGroupA )
05120 {
05121 a2dWalker_LayerCanvasObjects copyLayer;
05122 copyLayer.SetGroupA( a2dGetCmdh()->GetGroupA() );
05123 copyLayer.SetOperation( a2dWalker_LayerCanvasObjects::copyLayers );
05124 copyLayer.SetTarget( m_args.argValue.target );
05125
05126 copyLayer.Start( drawer->GetShowObject() );
05127 }
05128 else if (
05129 m_args.argValue.what == Boolean_OR ||
05130 m_args.argValue.what == Boolean_AND ||
05131 m_args.argValue.what == Boolean_EXOR ||
05132 m_args.argValue.what == Boolean_A_SUB_B ||
05133 m_args.argValue.what == Boolean_B_SUB_A ||
05134 m_args.argValue.what == Boolean_CORRECTION ||
05135 m_args.argValue.what == Boolean_SMOOTHEN ||
05136 m_args.argValue.what == Boolean_MAKERING ||
05137 m_args.argValue.what == Boolean_Polygon2Surface ||
05138 m_args.argValue.what == Boolean_Surface2Polygon
05139 )
05140 {
05141 #if wxART2D_USE_KBOOL
05142 a2dBooleanWalkerHandler booloper( a2dCanvasOFlags::VISIBLE );
05143 booloper.SetReleaseOrignals( false );
05144 booloper.SetClearTarget( m_args.argValue.clearTarget );
05145 booloper.SetGroupA( a2dGetCmdh()->GetGroupA() );
05146 booloper.SetGroupB( a2dGetCmdh()->GetGroupB() );
05147 booloper.SetTarget( m_args.argValue.target );
05148 booloper.SetSelectedOnlyA( m_args.argValue.selectedA );
05149 booloper.SetSelectedOnlyB( m_args.argValue.selectedB );
05150 booloper.SetRecursionDepth( 20 );
05151
05152 booloper.SetMarge( a2dGetCmdh()->m_MARGE/doc->GetUnitsScale() );
05153 booloper.SetGrid( a2dGetCmdh()->m_GRID );
05154 booloper.SetDGrid( a2dGetCmdh()->m_DGRID );
05155 booloper.SetCorrectionAber( a2dGetCmdh()->m_CORRECTIONABER/doc->GetUnitsScale() );
05156 booloper.SetCorrectionFactor( a2dGetCmdh()->m_CORRECTIONFACTOR/doc->GetUnitsScale() );
05157 booloper.SetMaxlinemerge( a2dGetCmdh()->m_MAXLINEMERGE/doc->GetUnitsScale() );
05158 booloper.SetWindingRule( a2dGetCmdh()->m_WINDINGRULE );
05159 booloper.SetRoundfactor( a2dGetCmdh()->m_ROUNDFACTOR );
05160 booloper.SetLinkHoles( true );
05161
05162 long boolOp = a2dBooleanWalkerHandler::Boolean_NON;
05163
05164 switch( m_args.argValue.what )
05165 {
05166 case Boolean_OR:
05167 {
05168 boolOp = a2dBooleanWalkerHandler::Boolean_OR;
05169 break;
05170 }
05171 case Boolean_AND:
05172 {
05173 boolOp = a2dBooleanWalkerHandler::Boolean_AND;
05174 break;
05175 }
05176 case Boolean_EXOR:
05177 {
05178 boolOp = a2dBooleanWalkerHandler::Boolean_EXOR;
05179 break;
05180 }
05181 case Boolean_A_SUB_B:
05182 {
05183 boolOp = a2dBooleanWalkerHandler::Boolean_A_SUB_B;
05184 break;
05185 }
05186 case Boolean_B_SUB_A:
05187 {
05188 boolOp = a2dBooleanWalkerHandler::Boolean_B_SUB_A;
05189 break;
05190 }
05191 case Boolean_CORRECTION:
05192 {
05193 booloper.SetCorrectionFactor( a2dGetCmdh()->m_CORRECTIONFACTOR/doc->GetUnitsScale() );
05194 boolOp = a2dBooleanWalkerHandler::Boolean_CORRECTION;
05195 break;
05196 }
05197 case Boolean_SMOOTHEN:
05198 {
05199 boolOp = a2dBooleanWalkerHandler::Boolean_SMOOTHEN;
05200 break;
05201 }
05202 case Boolean_MAKERING:
05203 {
05204 booloper.SetCorrectionFactor( fabs( a2dGetCmdh()->m_CORRECTIONFACTOR / 2.0/doc->GetUnitsScale()) );
05205 boolOp = a2dBooleanWalkerHandler::Boolean_MAKERING;
05206 break;
05207 }
05208 case Boolean_Polygon2Surface:
05209 {
05210 boolOp = a2dBooleanWalkerHandler::Boolean_Polygon2Surface;
05211 break;
05212 }
05213 case Boolean_Surface2Polygon:
05214 {
05215 boolOp = a2dBooleanWalkerHandler::Boolean_Surface2Polygon;
05216 break;
05217 }
05218 default:
05219 break;
05220 }
05221 booloper.SetOperation( boolOp );
05222 booloper.Start( drawer->GetShowObject() );
05223
05224 #endif //wxART2D_USE_KBOOL
05225 }
05226 else if ( m_args.argValue.what == DetectSmall )
05227 {
05228 a2dWalker_DetectSmall walk;
05229 walk.SetGroupA( a2dGetCmdh()->GetGroupA() );
05230 walk.SetTarget( m_args.argValue.target );
05231 double smallest = double( a2dGetCmdh()->GetSmall())/doc->GetUnitsScale();
05232 walk.SetSmall( smallest );
05233 walk.Start( drawer->GetShowObject() );
05234
05235 if ( m_args.argSet.fileNameOut )
05236 {
05237 wxFileOutputStream stream( m_args.argValue.fileNameOut );
05238 wxTextOutputStream streamw( stream );
05239 streamw << walk.GetString();
05240 }
05241
05242 }
05243 else if ( m_args.argValue.what == RemoveRedundant )
05244 {
05245 a2dWalker_LayerCanvasObjects removeredundant;
05246 removeredundant.SetGroupA( a2dGetCmdh()->GetGroupA() );
05247 removeredundant.SetTarget( m_args.argValue.target );
05248 removeredundant.SetOperation( a2dWalker_LayerCanvasObjects::RemoveRedundant );
05249 removeredundant.Start( drawer->GetShowObject() );
05250 }
05251 else
05252 return false;
05253 return true;
05254 }
05255
05256 bool a2dCommand_GroupAB::Undo()
05257 {
05258 return false;
05259 }
05260
05261
05262
05263
05264
05265
05266
05267 BEGIN_EVENT_TABLE(wxDoubleNumberEntryDialog, wxDialog)
05268 EVT_BUTTON(wxID_OK, wxDoubleNumberEntryDialog::OnOK)
05269 EVT_BUTTON(wxID_CANCEL, wxDoubleNumberEntryDialog::OnCancel)
05270 END_EVENT_TABLE()
05271
05272 IMPLEMENT_CLASS(wxDoubleNumberEntryDialog, wxDialog)
05273
05274 wxDoubleNumberEntryDialog::wxDoubleNumberEntryDialog(wxWindow *parent,
05275 const wxString& message,
05276 const wxString& prompt,
05277 const wxString& caption,
05278 double value,
05279 double min,
05280 double max,
05281 const wxPoint& pos)
05282 : wxDialog(parent, wxID_ANY, caption,
05283 pos, wxDefaultSize)
05284 {
05285 m_value = value;
05286 m_max = max;
05287 m_min = min;
05288
05289 wxBeginBusyCursor();
05290
05291 wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
05292 #if wxUSE_STATTEXT
05293
05294 topsizer->Add( CreateTextSizer( message ), 0, wxALL, 10 );
05295 #endif
05296
05297
05298 wxBoxSizer *inputsizer = new wxBoxSizer( wxHORIZONTAL );
05299
05300 #if wxUSE_STATTEXT
05301
05302 if (!prompt.empty())
05303 inputsizer->Add( new wxStaticText( this, wxID_ANY, prompt ), 0, wxCENTER | wxLEFT, 10 );
05304 #endif
05305
05306
05307 wxString valStr;
05308 valStr.Printf(wxT("%f"), m_value);
05309 m_textctrl = new wxTextCtrl(this, wxID_ANY, valStr, wxDefaultPosition, wxSize( 140, wxDefaultCoord ) );
05310 inputsizer->Add( m_textctrl, 1, wxCENTER | wxLEFT | wxRIGHT, 10 );
05311
05312 topsizer->Add( inputsizer, 0, wxEXPAND | wxLEFT|wxRIGHT, 5 );
05313
05314
05315 wxSizer *buttonSizer = CreateSeparatedButtonSizer(wxOK | wxCANCEL);
05316 if ( buttonSizer )
05317 {
05318 topsizer->Add(buttonSizer, wxSizerFlags().Expand().DoubleBorder());
05319 }
05320
05321 SetSizer( topsizer );
05322 SetAutoLayout( true );
05323
05324 topsizer->SetSizeHints( this );
05325 topsizer->Fit( this );
05326
05327 Centre( wxBOTH );
05328
05329 m_textctrl->SetSelection(-1, -1);
05330 m_textctrl->SetFocus();
05331
05332 wxEndBusyCursor();
05333 }
05334
05335 void wxDoubleNumberEntryDialog::OnOK(wxCommandEvent& WXUNUSED(event))
05336 {
05337 wxString tmp = m_textctrl->GetValue();
05338
05339 if ( !tmp.ToDouble( &m_value ) )
05340 EndModal(wxID_CANCEL);
05341 if ( m_value < m_min || m_value > m_max )
05342 {
05343
05344 m_value = -1;
05345 EndModal(wxID_CANCEL);
05346 }
05347
05348 EndModal(wxID_OK);
05349 }
05350
05351 void wxDoubleNumberEntryDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
05352 {
05353 EndModal(wxID_CANCEL);
05354 }
05355
05356
05357
05358
05359
05360
05361
05362 double wxGetDoubleNumberFromUser(const wxString& msg,
05363 const wxString& prompt,
05364 const wxString& title,
05365 double value,
05366 double min,
05367 double max,
05368 wxWindow *parent,
05369 const wxPoint& pos)
05370 {
05371 wxDoubleNumberEntryDialog dialog(parent, msg, prompt, title,
05372 value, min, max, pos);
05373 if (dialog.ShowModal() == wxID_OK)
05374 return dialog.GetValue();
05375
05376 return 0;
05377 }
05378
05379