thinkgeo.mapsuite.portablecore.edittools
Differences
This shows you the differences between two versions of the page.
| Next revision | Previous revision | ||
|
thinkgeo.mapsuite.portablecore.edittools [2015/08/20 03:08] 127.0.0.1 external edit |
thinkgeo.mapsuite.portablecore.edittools [2017/03/16 21:59] (current) |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== ThinkGeo.MapSuite.PortableCore.EditTools ====== | + | ====== ThinkGeo.MapSuite.Core.EditTools ====== |
| + | {{section>upgrade_map_suite_to_10.0}} | ||
| - | |||
| - | <!-- Class --> | ||
| - | This class is a wrapper class for the FeatureLayer that isolates only the editing methods to make them easily accessible to the programmer. | ||
| - | === Remarks === | ||
| This class is a wrapper class for the FeatureLayer that isolates only the editing methods to make them easily accessible to the programmer. | This class is a wrapper class for the FeatureLayer that isolates only the editing methods to make them easily accessible to the programmer. | ||
| ===== Inheritance Hierarchy ===== | ===== Inheritance Hierarchy ===== | ||
| - | *System.Object | + | *System.Object |
| - | **[[ThinkGeo.MapSuite.PortableCore.EditTools]] | + | ***ThinkGeo.MapSuite.Core.EditTools** |
| ===== Members Summary ===== | ===== Members Summary ===== | ||
| ==== Public Constructors ==== | ==== Public Constructors ==== | ||
| - | ^ Name ^ Parameters ^ DeclaringType ^ Summary ^ | + | ** {{wiki:PublicMethod.gif|}} EditTools(FeatureSource) ** |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#EditTools(FeatureSource)|EditTools]] | [[ThinkGeo.MapSuite.PortableCore.FeatureSource|FeatureSource]] | | This is a constructor for the class. | | + | |
| + | * //This is a constructor for the class.// | ||
| + | == Remarks == | ||
| + | * //None// | ||
| + | == Parameters == | ||
| + | * //featureSource// | ||
| + | * Type:[[ThinkGeo.MapSuite.Core.FeatureSource|FeatureSource]] | ||
| + | * Description:This parameter is the FeatureSource that the edit operations will pass through to. | ||
| + | |||
| + | <div newline></div> | ||
| ==== Protected Constructors ==== | ==== Protected Constructors ==== | ||
| - | ^ Name ^ Parameters ^ DeclaringType ^ Summary ^ | + | ** {{wiki:ProtectedMethod.gif|}} EditTools() ** |
| - | | {{wiki:ProtectedMethod.gif|Protected Method}}[[#EditTools()|EditTools]] | | | This is a constructor for the class. | | + | |
| + | * //This is a constructor for the class.// | ||
| + | == Remarks == | ||
| + | * //This is the default constructor. It is protected and not meant to be used.// | ||
| + | == Parameters == | ||
| + | <div newline></div> | ||
| ==== Public Methods ==== | ==== Public Methods ==== | ||
| - | ^ Name ^ Parameters ^ DeclaringType ^ Summary ^ | + | ** {{wiki:PublicMethod.gif|}} BeginTransaction() ** |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Add(BaseShape)|Add]] | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]] | | This method adds a new Feature to an existing transaction. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Add(Feature)|Add]] | [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]] | | This method adds a new Feature to an existing transaction. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Add(BaseShape, Dictionary<String, String>)|Add]] | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]], Dictionary<String, String> | | This overload allows you pass in a Feature. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#BeginTransaction()|BeginTransaction]] | | | This method starts a new transaction if the FeatureLayer allows editing. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#CommitTransaction()|CommitTransaction]] | | | This method will commit the existing transaction to its underlying source of data. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Delete(String)|Delete]] | String | | This method deletes a Feature from an existing transaction. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Equals(Object)|Equals]] | Object | Object | | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#GetDifference(String, AreaBaseShape)|GetDifference]] | String, [[ThinkGeo.MapSuite.PortableCore.AreaBaseShape|AreaBaseShape]] | | This method returns the difference between two shapes, which are defined as the set of all points that lie in the Feature but not in the targetShape. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#GetDifference(String, Feature)|GetDifference]] | String, [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]] | | This method returns the difference between two features, which are defined as the set of all points which lie in the Feature but not in the targetFeature. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#GetHashCode()|GetHashCode]] | | Object | | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#GetType()|GetType]] | | Object | | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#RollbackTransaction()|RollbackTransaction]] | | | This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Rotate(String, PointShape, Single)|Rotate]] | String, [[ThinkGeo.MapSuite.PortableCore.PointShape|PointShape]], Single | | This method rotates the Feature any number of degrees based on a pivot point. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#ScaleDown(String, Double)|ScaleDown]] | String, Double | | This method decreases the size of the feature by the percentage given in the percentage parameter. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#ScaleUp(String, Double)|ScaleUp]] | String, Double | | This method increases the size of the feature by the percentage given in the percentage parameter. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#ToString()|ToString]] | | Object | | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#TranslateByDegree(String, Double, Double, GeographyUnit, DistanceUnit)|TranslateByDegree]] | String, Double, Double, [[ThinkGeo.MapSuite.PortableCore.GeographyUnit|GeographyUnit]], [[ThinkGeo.MapSuite.PortableCore.DistanceUnit|DistanceUnit]] | | This method moves the Feature from one location to another based on a distance and a direction in degrees. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#TranslateByOffset(String, Double, Double, GeographyUnit, DistanceUnit)|TranslateByOffset]] | String, Double, Double, [[ThinkGeo.MapSuite.PortableCore.GeographyUnit|GeographyUnit]], [[ThinkGeo.MapSuite.PortableCore.DistanceUnit|DistanceUnit]] | | This method moves the Feature from one location to another based on a X and Y offset distance. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Union(String, Feature)|Union]] | String, [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]] | | This method returns the union of the Feature and the target features, which are defined as the set of all points in the Feature or the target shape. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Union(String, AreaBaseShape)|Union]] | String, [[ThinkGeo.MapSuite.PortableCore.AreaBaseShape|AreaBaseShape]] | | This method returns the union of the Feature and the target shapes, which are defined as the set of all points in the Feature or the target shape. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Update(BaseShape)|Update]] | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]] | | This method updates a Feature in an existing transaction. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Update(Feature)|Update]] | [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]] | | This method updates a Feature in an existing transaction. | | + | |
| - | | {{wiki:PublicMethod.gif|Public Method}}[[#Update(BaseShape, Dictionary<String, String>)|Update]] | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]], Dictionary<String, String> | | This method updates a Feature in an existing transaction. | | + | |
| - | ==== Protected Methods ==== | + | * //This method starts a new transaction if the FeatureLayer allows editing.// |
| - | ^ Name ^ Parameters ^ DeclaringType ^ Summary ^ | + | == Remarks == |
| - | | {{wiki:ProtectedMethod.gif|Protected Method}}[[#Finalize()|Finalize]] | | Object | | | + | * //This method is used to start a transaction, assuming that the FeatureLayer allows editing. There are some additional prerequisites to beginning a transaction, such as ensuring that a transaction is not already in progress. You must also be sure that the FeatureSource has been opened. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// |
| - | | {{wiki:ProtectedMethod.gif|Protected Method}}[[#MemberwiseClone()|MemberwiseClone]] | | Object | | | + | |
| - | ==== Public Properties ==== | + | == Return Value == |
| - | ^ Name ^ Return ^ DeclaringType ^ Summary ^ | + | * Type:Void |
| - | | {{wiki:PublicProperty.gif|Public Property}}[[#IsEditable|IsEditable]] | Boolean | | This property returns whether the FeatureLayer allows edits or is read only. | | + | * Description:None |
| - | | {{wiki:PublicProperty.gif|Public Property}}[[#IsInTransaction|IsInTransaction]] | Boolean | | This property returns true if the FeatureLayer is in a transaction and false if it is not. | | + | |
| - | | {{wiki:PublicProperty.gif|Public Property}}[[#IsTransactionLive|IsTransactionLive]] | Boolean | | This property returns true if the features currently modified in a transaction are expected to reflect their state when calling other methods on the FeatureLayer, such as spatial queries. | | + | |
| - | | {{wiki:PublicProperty.gif|Public Property}}[[#TransactionBuffer|TransactionBuffer]] | [[ThinkGeo.MapSuite.PortableCore.TransactionBuffer|TransactionBuffer]] | | This property allows you get and set the transaction buffer. | | + | |
| - | ==== Protected Properties ==== | + | == Parameters == |
| - | ^ Name ^ Return ^ DeclaringType ^ Summary ^ | + | <div newline></div> |
| + | ** {{wiki:PublicMethod.gif|}} Add(BaseShape) ** | ||
| - | ==== Public Events ==== | + | * //This method adds a new Feature to an existing transaction.// |
| - | ^ Name ^ Event Arguments ^ DeclaringType ^ Summary ^ | + | == Remarks == |
| + | * //This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// | ||
| - | ===== Public Constructors ===== | + | == Return Value == |
| - | ==== EditTools(FeatureSource) ==== | + | * Type:String |
| - | This is a constructor for the class. | + | * Description:This string is the ID that will uniquely identify this Feature while it is in a transaction. |
| - | === Overloads === | + | |
| - | This constructor allows you to pass in the FeatureSource. | + | |
| - | === Parameters === | + | |
| - | ^ Name ^ Type ^ Description ^ | + | |
| - | | featureSource | [[ThinkGeo.MapSuite.PortableCore.FeatureSource|FeatureSource]]<!-- ThinkGeo.MapSuite.PortableCore.FeatureSource --> | This parameter is the FeatureSource that the edit operations will pass through to. | | + | |
| - | [[#Public Constructors|Go Back]] | + | == Parameters == |
| - | ===== Protected Constructors ===== | + | * //shape// |
| - | ==== EditTools() ==== | + | * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]] |
| - | This is a constructor for the class. | + | * Description:This parameter represents the new shape that will be added to the transaction. |
| - | === Overloads === | + | |
| - | This is the default constructor. It is protected and not meant to be used. | + | |
| - | === Remarks === | + | |
| - | This is the default constructor. It is protected and not meant to be used. | + | |
| - | === Parameters === | + | |
| - | ^ Name ^ Type ^ Description ^ | + | |
| - | [[#Protected Constructors|Go Back]] | + | <div newline></div> |
| - | ===== Public Methods ===== | + | ** {{wiki:PublicMethod.gif|}} Add(Feature) ** |
| - | ==== Add(BaseShape) ==== | + | |
| - | This method adds a new Feature to an existing transaction. | + | |
| - | === Overloads === | + | |
| - | This overload allows you to pass in a shape. | + | |
| - | === Remarks === | + | |
| - | This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | * //This method adds a new Feature to an existing transaction.// |
| + | == Remarks == | ||
| + | * //This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | == Return Value == |
| + | * Type:String | ||
| + | * Description:This string is the ID that will uniquely identify this Feature while it is in a transaction. | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | == Parameters == |
| + | * //feature// | ||
| + | * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]] | ||
| + | * Description:This parameter represents the new Feature that will be added to the transaction. | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | <div newline></div> |
| + | ** {{wiki:PublicMethod.gif|}} Add(BaseShape,Dictionary<String,String>) ** | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | * //N/A// |
| - | === Return Value === | + | == Remarks == |
| - | ^ Return Type ^ Description ^ | + | * //N/A// |
| - | | String<!-- System.String --> | This string is the ID that will uniquely identify this Feature while it is in a transaction. | | + | |
| - | === Parameters === | + | == Return Value == |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:String |
| - | | shape | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]]<!-- ThinkGeo.MapSuite.PortableCore.BaseShape --> | This parameter represents the new shape that will be added to the transaction. | | + | * Description:N/A |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Parameters == |
| - | [[#Public Methods|Go Back]] | + | * //shape// |
| - | ==== Add(Feature) ==== | + | * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]] |
| - | This method adds a new Feature to an existing transaction. | + | * Description:N/A |
| - | === Overloads === | + | |
| - | This overload allows you pass in a Feature. | + | |
| - | === Remarks === | + | |
| - | This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | * //columnValues// |
| + | * Type:Dictionary<String,String> | ||
| + | * Description:N/A | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | <div newline></div> |
| + | ** {{wiki:PublicMethod.gif|}} ScaleUp(String,Double) ** | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | * //This method increases the size of the feature by the percentage given in the percentage parameter.// |
| + | == Remarks == | ||
| + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method is useful when you would like to increase the size of the Feature. Note that a larger percentage will scale the shape up faster as you apply the operation multiple times. There is also a ScaleDown method that will shrink the shape as well.// | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | == Return Value == |
| + | * Type:Void | ||
| + | * Description:N/A | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | == Parameters == |
| - | === Return Value === | + | * //featureId// |
| - | ^ Return Type ^ Description ^ | + | * Type:String |
| - | | String<!-- System.String --> | This string is the ID that will uniquely identify this Feature while it is in a transaction. | | + | * Description:This parameter is the Id of the Feature you want to scale. |
| - | === Parameters === | + | * //percentage// |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:Double |
| - | | feature | [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]]<!-- ThinkGeo.MapSuite.PortableCore.Feature --> | This parameter represents the new Feature that will be added to the transaction. | | + | * Description:This is the percentage by which to increase the Feature's size. |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | <div newline></div> |
| - | [[#Public Methods|Go Back]] | + | ** {{wiki:PublicMethod.gif|}} ScaleDown(String,Double) ** |
| - | ==== Add(BaseShape, Dictionary<String, String>) ==== | + | |
| - | This overload allows you pass in a Feature. | + | |
| - | === Overloads === | + | |
| - | This overload allows you pass in a Feature. | + | |
| - | === Remarks === | + | |
| - | This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | * //This method decreases the size of the feature by the percentage given in the percentage parameter.// |
| + | == Remarks == | ||
| + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method is useful when you would like to decrease the size of the Feature. Note that a larger percentage will scale the shape down faster as you apply the operation multiple times. There is also a ScaleUp method that will expand the shape as well.// | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | == Return Value == |
| + | * Type:Void | ||
| + | * Description:N/A | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | == Parameters == |
| + | * //featureId// | ||
| + | * Type:String | ||
| + | * Description:This parameter is the Id of the Feature you want to scale. | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | * //percentage// |
| + | * Type:Double | ||
| + | * Description:This is the percentage by which to decrease the Feature's size. | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | <div newline></div> |
| - | === Return Value === | + | ** {{wiki:PublicMethod.gif|}} TranslateByDegree(String,Double,Double,GeographyUnit,DistanceUnit) ** |
| - | ^ Return Type ^ Description ^ | + | |
| - | | String<!-- System.String --> | This string is the ID that will uniquely identify this BaseShape while it is in a transaction. | | + | |
| - | === Parameters === | + | * //This method moves the Feature from one location to another based on a distance and a direction in degrees.// |
| - | ^ Name ^ Type ^ Description ^ | + | == Remarks == |
| - | | shape | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]]<!-- ThinkGeo.MapSuite.PortableCore.BaseShape --> | This parameter represents the new BaseShape that will be added to the transaction. | | + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method moves the Feature from one location to another based on angleInDegrees and the distance parameter. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with a specified distanceUnit of miles, you're going to move this shape a number of miles based on the distance and angleInDegrees. In this way, you could easily move a shape in decimal degrees five miles to the north.If you pass a distance of 0, the operation is ignored.// |
| - | | columnValues | Dictionary<String,String><!-- System.Collections.Generic.Dictionary{System.String,System.String} --> | This parameter represents DBF information of the new BaseShape. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Return Value == |
| - | [[#Public Methods|Go Back]] | + | * Type:Void |
| - | ==== BeginTransaction() ==== | + | * Description:None |
| - | This method starts a new transaction if the FeatureLayer allows editing. | + | |
| - | === Remarks === | + | |
| - | This method is used to start a transaction, assuming that the FeatureLayer allows editing. There are some additional prerequisites to beginning a transaction, such as ensuring that a transaction is not already in progress. You must also be sure that the FeatureSource has been opened. | + | |
| - | The Transaction System | + | == Parameters == |
| + | * //featureId// | ||
| + | * Type:String | ||
| + | * Description:This parameter is the Feature you want to move. | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | * //distance// |
| + | * Type:Double | ||
| + | * Description:The distance is the number of units to move the shape using the angle specified. The distance unit will be the DistanceUnit specified in the distanceUnit parameter. The distance must be greater than or equal to 0. | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | * //angleInDegrees// |
| + | * Type:Double | ||
| + | * Description:A number between 0 and 360 degrees that represents the direction you wish to move the shape, with zero being up. | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | * //shapeUnit// |
| + | * Type:[[ThinkGeo.MapSuite.Core.GeographyUnit|GeographyUnit]] | ||
| + | * Description:This is the GeographicUnit of the shape you are performing the operation on. | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | * //distanceUnit// |
| - | === Return Value === | + | * Type:[[ThinkGeo.MapSuite.Core.DistanceUnit|DistanceUnit]] |
| - | ^ Return Type ^ Description ^ | + | * Description:This is the DistanceUnit you would like to use as the measure of the translate. For example, if you select miles as your distanceUnit, then the distance will be calculated in miles. |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | <div newline></div> |
| - | ^ Name ^ Type ^ Description ^ | + | ** {{wiki:PublicMethod.gif|}} TranslateByOffset(String,Double,Double,GeographyUnit,DistanceUnit) ** |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | * //This method moves the Feature from one location to another based on a X and Y offset distance.// |
| - | [[#Public Methods|Go Back]] | + | == Remarks == |
| - | ==== CommitTransaction() ==== | + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method moves the Feature from one location to another based on an X and Y offset distance. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with an X offset of 1 and a Y offset of 1, you're going to move this Feature one unit of the distanceUnit in the horizontal direction and one unit of the distanceUnit in the vertical direction. In this way, you could easily move a Feature in decimal degrees five miles on the X axis and 3 miles on the Y axis.// |
| - | This method will commit the existing transaction to its underlying source of data. | + | |
| - | === Remarks === | + | |
| - | This method will commit the existing transaction to its underlying source of data. It will then pass back the results of the commit, including any error(s) received. Finally, it will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | == Return Value == |
| + | * Type:Void | ||
| + | * Description:None | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | == Parameters == |
| + | * //featureId// | ||
| + | * Type:String | ||
| + | * Description:This parameter is the Feature you want to move. | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | * //xOffset// |
| + | * Type:Double | ||
| + | * Description:This is the number of horizontal units of movement in the DistanceUnit specified in the distanceUnit parameter. | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | * //yOffset// |
| + | * Type:Double | ||
| + | * Description:This is the number of horizontal units of movement in the DistanceUnit specified in the distanceUnit parameter. | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | * //shapeUnit// |
| - | === Return Value === | + | * Type:[[ThinkGeo.MapSuite.Core.GeographyUnit|GeographyUnit]] |
| - | ^ Return Type ^ Description ^ | + | * Description:This is the GeographicUnit of the shape you are performing the operation on. |
| - | | [[ThinkGeo.MapSuite.PortableCore.TransactionResult|TransactionResult]]<!-- ThinkGeo.MapSuite.PortableCore.TransactionResult --> | The returned decimalDegreesValue of this method is a TransactionResult class, which gives you the status of the transaction you just committed. It includes how many of the updates, adds, and deletes were successful and any errors that were encountered during the committing of the transaction. | | + | |
| - | === Parameters === | + | * //offsetUnit// |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:[[ThinkGeo.MapSuite.Core.DistanceUnit|DistanceUnit]] |
| + | * Description:This is the DistanceUnit you would like to use as the measure of the translate. For example, if you select miles as your distanceUnit, then the xOffsetDistance and yOffsetDistance will be calculated in miles. | ||
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | <div newline></div> |
| - | [[#Public Methods|Go Back]] | + | ** {{wiki:PublicMethod.gif|}} Rotate(String,PointShape,Single) ** |
| - | ==== Delete(String) ==== | + | |
| - | This method deletes a Feature from an existing transaction. | + | |
| - | === Remarks === | + | |
| - | This method deletes a Feature from an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | * //This method rotates the Feature any number of degrees based on a pivot point.// |
| + | == Remarks == | ||
| + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method rotates the Feature based on a pivot point by a number of degrees. By placing the pivot point in the center of the Feature, you can achieve in-place rotation. By moving the pivot point outside of the center of the Feature, you can translate the shape in a circular motion. Moving the pivot point further outside of the center will make the circular area larger.// | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | == Return Value == |
| + | * Type:Void | ||
| + | * Description:None | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | == Parameters == |
| + | * //featureId// | ||
| + | * Type:String | ||
| + | * Description:This parameter is the Feature you want to rotate. | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | * //pivotPoint// |
| + | * Type:[[ThinkGeo.MapSuite.Core.PointShape|PointShape]] | ||
| + | * Description:The pivotPoint represents the center of rotation. | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | * //degreeAngle// |
| - | === Return Value === | + | * Type:Single |
| - | ^ Return Type ^ Description ^ | + | * Description:The number of degrees of rotation, from 0 to 360. |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | <div newline></div> |
| - | ^ Name ^ Type ^ Description ^ | + | ** {{wiki:PublicMethod.gif|}} Union(String,AreaBaseShape) ** |
| - | | id | String<!-- System.String --> | This string is the Id of the feature in the FeatureLayer that you wish to delete. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | * //This method returns the union of the Feature and the target shapes, which are defined as the set of all points in the Feature or the target shape.// |
| - | [[#Public Methods|Go Back]] | + | == Remarks == |
| - | ==== Equals(Object) ==== | + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This is useful for adding area shapes together to form a larger area shape.// |
| - | === Return Value === | + | |
| - | ^ Return Type ^ Description ^ | + | |
| - | | Boolean<!-- System.Boolean --> | | | + | |
| - | === Parameters === | + | == Return Value == |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:Void |
| - | | obj | Object<!-- System.Object --> | | | + | * Description:None |
| - | <!-- System.Object --> | + | == Parameters == |
| - | [[#Public Methods|Go Back]] | + | * //featureId// |
| - | ==== GetDifference(String, AreaBaseShape) ==== | + | * Type:String |
| - | This method returns the difference between two shapes, which are defined as the set of all points that lie in the Feature but not in the targetShape. | + | * Description:This parameter is the Feature you want to add the new area to. |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | === Return Value === | + | |
| - | ^ Return Type ^ Description ^ | + | |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | * //targetShape// |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:[[ThinkGeo.MapSuite.Core.AreaBaseShape|AreaBaseShape]] |
| - | | featureId | String<!-- System.String --> | This is the Feature you want to remove area from. | | + | * Description:The shape you are trying to find the union with. |
| - | | targetShape | [[ThinkGeo.MapSuite.PortableCore.AreaBaseShape|AreaBaseShape]]<!-- ThinkGeo.MapSuite.PortableCore.AreaBaseShape --> | The shape you are trying to find the difference with. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | <div newline></div> |
| - | [[#Public Methods|Go Back]] | + | ** {{wiki:PublicMethod.gif|}} Union(String,Feature) ** |
| - | ==== GetDifference(String, Feature) ==== | + | |
| - | This method returns the difference between two features, which are defined as the set of all points which lie in the Feature but not in the targetFeature. | + | |
| - | === Return Value === | + | |
| - | ^ Return Type ^ Description ^ | + | |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | * //This method returns the union of the Feature and the target features, which are defined as the set of all points in the Feature or the target shape.// |
| - | ^ Name ^ Type ^ Description ^ | + | == Remarks == |
| - | | featureId | String<!-- System.String --> | This is the Feature you want to remove area from. | | + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This is useful for adding area shapes together to form a larger area shape.// |
| - | | targetAreaFeature | [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]]<!-- ThinkGeo.MapSuite.PortableCore.Feature --> | The feature you are trying to find the difference with. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Return Value == |
| - | [[#Public Methods|Go Back]] | + | * Type:Void |
| - | ==== GetHashCode() ==== | + | * Description:None |
| - | === Return Value === | + | |
| - | ^ Return Type ^ Description ^ | + | |
| - | | Int32<!-- System.Int32 --> | | | + | |
| - | === Parameters === | + | == Parameters == |
| - | ^ Name ^ Type ^ Description ^ | + | * //featureId// |
| + | * Type:String | ||
| + | * Description:This parameter is the Feature you want to add the new area to. | ||
| - | <!-- System.Object --> | + | * //targetAreaFeature// |
| - | [[#Public Methods|Go Back]] | + | * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]] |
| - | ==== GetType() ==== | + | * Description:The feature you are trying to find the union with. |
| - | === Return Value === | + | |
| - | ^ Return Type ^ Description ^ | + | |
| - | | Type<!-- System.Type --> | | | + | |
| - | === Parameters === | + | <div newline></div> |
| - | ^ Name ^ Type ^ Description ^ | + | ** {{wiki:PublicMethod.gif|}} GetDifference(String,AreaBaseShape) ** |
| - | <!-- System.Object --> | + | * //This method returns the difference between two shapes, which are defined as the set of all points that lie in the Feature but not in the targetShape.// |
| - | [[#Public Methods|Go Back]] | + | == Remarks == |
| - | ==== RollbackTransaction() ==== | + | * //This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.// |
| - | This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted. | + | |
| - | === Remarks === | + | |
| - | This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | == Return Value == |
| + | * Type:Void | ||
| + | * Description:None | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | == Parameters == |
| + | * //featureId// | ||
| + | * Type:String | ||
| + | * Description:This is the Feature you want to remove area from. | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | * //targetShape// |
| + | * Type:[[ThinkGeo.MapSuite.Core.AreaBaseShape|AreaBaseShape]] | ||
| + | * Description:The shape you are trying to find the difference with. | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | <div newline></div> |
| + | ** {{wiki:PublicMethod.gif|}} GetDifference(String,Feature) ** | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | * //This method returns the difference between two features, which are defined as the set of all points which lie in the Feature but not in the targetFeature.// |
| - | === Return Value === | + | == Remarks == |
| - | ^ Return Type ^ Description ^ | + | * //N/A// |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | == Return Value == |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:Void |
| + | * Description:None | ||
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Parameters == |
| - | [[#Public Methods|Go Back]] | + | * //featureId// |
| - | ==== Rotate(String, PointShape, Single) ==== | + | * Type:String |
| - | This method rotates the Feature any number of degrees based on a pivot point. | + | * Description:This is the Feature you want to remove area from. |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | This method rotates the Feature based on a pivot point by a number of degrees. By placing the pivot point in the center of the Feature, you can achieve in-place rotation. By moving the pivot point outside of the center of the Feature, you can translate the shape in a circular motion. Moving the pivot point further outside of the center will make the circular area larger. | + | * //targetAreaFeature// |
| - | === Return Value === | + | * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]] |
| - | ^ Return Type ^ Description ^ | + | * Description:The feature you are trying to find the difference with. |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | <div newline></div> |
| - | ^ Name ^ Type ^ Description ^ | + | ** {{wiki:PublicMethod.gif|}} Delete(String) ** |
| - | | featureId | String<!-- System.String --> | This parameter is the Feature you want to rotate. | | + | |
| - | | pivotPoint | [[ThinkGeo.MapSuite.PortableCore.PointShape|PointShape]]<!-- ThinkGeo.MapSuite.PortableCore.PointShape --> | The pivotPoint represents the center of rotation. | | + | |
| - | | degreeAngle | Single<!-- System.Single --> | The number of degrees of rotation, from 0 to 360. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | * //This method deletes a Feature from an existing transaction.// |
| - | [[#Public Methods|Go Back]] | + | == Remarks == |
| - | ==== ScaleDown(String, Double) ==== | + | * //This method deletes a Feature from an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// |
| - | This method decreases the size of the feature by the percentage given in the percentage parameter. | + | |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | This method is useful when you would like to decrease the size of the Feature. Note that a larger percentage will scale the shape down faster as you apply the operation multiple times. There is also a ScaleUp method that will expand the shape as well. | + | == Return Value == |
| - | === Return Value === | + | * Type:Void |
| - | ^ Return Type ^ Description ^ | + | * Description:None |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | == Parameters == |
| - | ^ Name ^ Type ^ Description ^ | + | * //id// |
| - | | featureId | String<!-- System.String --> | This parameter is the Id of the Feature you want to scale. | | + | * Type:String |
| - | | percentage | Double<!-- System.Double --> | This is the percentage by which to decrease the Feature's size. | | + | * Description:This string is the Id of the feature in the FeatureLayer that you wish to delete. |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | <div newline></div> |
| - | [[#Public Methods|Go Back]] | + | ** {{wiki:PublicMethod.gif|}} Update(BaseShape) ** |
| - | ==== ScaleUp(String, Double) ==== | + | |
| - | This method increases the size of the feature by the percentage given in the percentage parameter. | + | |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | This method is useful when you would like to increase the size of the Feature. Note that a larger percentage will scale the shape up faster as you apply the operation multiple times. There is also a ScaleDown method that will shrink the shape as well. | + | * //This method updates a Feature in an existing transaction.// |
| - | === Return Value === | + | == Remarks == |
| - | ^ Return Type ^ Description ^ | + | * //This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | == Return Value == |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:Void |
| - | | featureId | String<!-- System.String --> | This parameter is the Id of the Feature you want to scale. | | + | * Description:None |
| - | | percentage | Double<!-- System.Double --> | This is the percentage by which to increase the Feature's size. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Parameters == |
| - | [[#Public Methods|Go Back]] | + | * //shape// |
| - | ==== ToString() ==== | + | * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]] |
| - | === Return Value === | + | * Description:The shape you wish to update in the transaction. The Id of the Shape should be the feature Id which you wish to update. |
| - | ^ Return Type ^ Description ^ | + | |
| - | | String<!-- System.String --> | | | + | |
| - | === Parameters === | + | <div newline></div> |
| - | ^ Name ^ Type ^ Description ^ | + | ** {{wiki:PublicMethod.gif|}} Update(Feature) ** |
| - | <!-- System.Object --> | + | * //This method updates a Feature in an existing transaction.// |
| - | [[#Public Methods|Go Back]] | + | == Remarks == |
| - | ==== TranslateByDegree(String, Double, Double, GeographyUnit, DistanceUnit) ==== | + | * //This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// |
| - | This method moves the Feature from one location to another based on a distance and a direction in degrees. | + | |
| - | === Overloads === | + | |
| - | In this overload, the distance unit is based on a DistanceUnit you specify in the distanceUnit parameter, regardless of the shape's GeographicUnit. | + | |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | This method moves the Feature from one location to another based on angleInDegrees and the distance parameter. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with a specified distanceUnit of miles, you're going to move this shape a number of miles based on the distance and angleInDegrees. In this way, you could easily move a shape in decimal degrees five miles to the north. | + | == Return Value == |
| + | * Type:Void | ||
| + | * Description:None | ||
| - | If you pass a distance of 0, the operation is ignored. | + | == Parameters == |
| - | === Return Value === | + | * //feature// |
| - | ^ Return Type ^ Description ^ | + | * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]] |
| - | | Void<!-- System.Void --> | | | + | * Description:The Feature you wish to update in the transaction. |
| - | === Parameters === | + | <div newline></div> |
| - | ^ Name ^ Type ^ Description ^ | + | ** {{wiki:PublicMethod.gif|}} Update(BaseShape,Dictionary<String,String>) ** |
| - | | featureId | String<!-- System.String --> | This parameter is the Feature you want to move. | | + | |
| - | | distance | Double<!-- System.Double --> | The distance is the number of units to move the shape using the angle specified. The distance unit will be the DistanceUnit specified in the distanceUnit parameter. The distance must be greater than or equal to 0. | | + | |
| - | | angleInDegrees | Double<!-- System.Double --> | A number between 0 and 360 degrees that represents the direction you wish to move the shape, with zero being up. | | + | |
| - | | shapeUnit | [[ThinkGeo.MapSuite.PortableCore.GeographyUnit|GeographyUnit]]<!-- ThinkGeo.MapSuite.PortableCore.GeographyUnit --> | This is the GeographicUnit of the shape you are performing the operation on. | | + | |
| - | | distanceUnit | [[ThinkGeo.MapSuite.PortableCore.DistanceUnit|DistanceUnit]]<!-- ThinkGeo.MapSuite.PortableCore.DistanceUnit --> | This is the DistanceUnit you would like to use as the measure of the translate. For example, if you select miles as your distanceUnit, then the distance will be calculated in miles. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | * //N/A// |
| - | [[#Public Methods|Go Back]] | + | == Remarks == |
| - | ==== TranslateByOffset(String, Double, Double, GeographyUnit, DistanceUnit) ==== | + | * //N/A// |
| - | This method moves the Feature from one location to another based on a X and Y offset distance. | + | |
| - | === Overloads === | + | |
| - | In this overload, the X and Y offset are based on a DistanceUnit you specify, regardless of the shape's GeographicUnit. | + | |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | This method moves the Feature from one location to another based on an X and Y offset distance. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with an X offset of 1 and a Y offset of 1, you're going to move this Feature one unit of the distanceUnit in the horizontal direction and one unit of the distanceUnit in the vertical direction. In this way, you could easily move a Feature in decimal degrees five miles on the X axis and 3 miles on the Y axis. | + | == Return Value == |
| - | === Return Value === | + | * Type:Void |
| - | ^ Return Type ^ Description ^ | + | * Description:N/A |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | == Parameters == |
| - | ^ Name ^ Type ^ Description ^ | + | * //shape// |
| - | | featureId | String<!-- System.String --> | This parameter is the Feature you want to move. | | + | * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]] |
| - | | xOffset | Double<!-- System.Double --> | This is the number of horizontal units of movement in the DistanceUnit specified in the distanceUnit parameter. | | + | * Description:N/A |
| - | | yOffset | Double<!-- System.Double --> | This is the number of horizontal units of movement in the DistanceUnit specified in the distanceUnit parameter. | | + | |
| - | | shapeUnit | [[ThinkGeo.MapSuite.PortableCore.GeographyUnit|GeographyUnit]]<!-- ThinkGeo.MapSuite.PortableCore.GeographyUnit --> | This is the GeographicUnit of the shape you are performing the operation on. | | + | |
| - | | offsetUnit | [[ThinkGeo.MapSuite.PortableCore.DistanceUnit|DistanceUnit]]<!-- ThinkGeo.MapSuite.PortableCore.DistanceUnit --> | This is the DistanceUnit you would like to use as the measure of the translate. For example, if you select miles as your distanceUnit, then the xOffsetDistance and yOffsetDistance will be calculated in miles. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | * //columnValues// |
| - | [[#Public Methods|Go Back]] | + | * Type:Dictionary<String,String> |
| - | ==== Union(String, Feature) ==== | + | * Description:N/A |
| - | This method returns the union of the Feature and the target features, which are defined as the set of all points in the Feature or the target shape. | + | |
| - | === Overloads === | + | |
| - | This overload allows you pass in a Feature. | + | |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | This is useful for adding area shapes together to form a larger area shape. | + | <div newline></div> |
| - | === Return Value === | + | ** {{wiki:PublicMethod.gif|}} RollbackTransaction() ** |
| - | ^ Return Type ^ Description ^ | + | |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | * //This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted.// |
| - | ^ Name ^ Type ^ Description ^ | + | == Remarks == |
| - | | featureId | String<!-- System.String --> | This parameter is the Feature you want to add the new area to. | | + | * //This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// |
| - | | targetAreaFeature | [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]]<!-- ThinkGeo.MapSuite.PortableCore.Feature --> | The feature you are trying to find the union with. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Return Value == |
| - | [[#Public Methods|Go Back]] | + | * Type:Void |
| - | ==== Union(String, AreaBaseShape) ==== | + | * Description:None |
| - | This method returns the union of the Feature and the target shapes, which are defined as the set of all points in the Feature or the target shape. | + | |
| - | === Overloads === | + | |
| - | This overload allows you pass in an AreaBaseShape. | + | |
| - | === Remarks === | + | |
| - | This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. | + | |
| - | This is useful for adding area shapes together to form a larger area shape. | + | == Parameters == |
| - | === Return Value === | + | <div newline></div> |
| - | ^ Return Type ^ Description ^ | + | ** {{wiki:PublicMethod.gif|}} CommitTransaction() ** |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | * //This method will commit the existing transaction to its underlying source of data.// |
| - | ^ Name ^ Type ^ Description ^ | + | == Remarks == |
| - | | featureId | String<!-- System.String --> | This parameter is the Feature you want to add the new area to. | | + | * //This method will commit the existing transaction to its underlying source of data. It will then pass back the results of the commit, including any error(s) received. Finally, it will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// |
| - | | targetShape | [[ThinkGeo.MapSuite.PortableCore.AreaBaseShape|AreaBaseShape]]<!-- ThinkGeo.MapSuite.PortableCore.AreaBaseShape --> | The shape you are trying to find the union with. | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Return Value == |
| - | [[#Public Methods|Go Back]] | + | * Type:[[ThinkGeo.MapSuite.Core.TransactionResult|TransactionResult]] |
| - | ==== Update(BaseShape) ==== | + | * Description:The returned decimalDegreesValue of this method is a TransactionResult class, which gives you the status of the transaction you just committed. It includes how many of the updates, adds, and deletes were successful and any errors that were encountered during the committing of the transaction. |
| - | This method updates a Feature in an existing transaction. | + | |
| - | === Overloads === | + | |
| - | This overload allows you to pass in a shape and the Id to the Feature it will update. | + | |
| - | === Remarks === | + | |
| - | This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | == Parameters == |
| + | <div newline></div> | ||
| + | ** {{wiki:PublicMethod.gif|}} ToString() ** | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | * //N/A// |
| + | == Remarks == | ||
| + | * //N/A// | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | == Return Value == |
| + | * Type:String | ||
| + | * Description:N/A | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | == Parameters == |
| + | <div newline></div> | ||
| + | ** {{wiki:PublicMethod.gif|}} Equals(Object) ** | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | * //N/A// |
| - | === Return Value === | + | == Remarks == |
| - | ^ Return Type ^ Description ^ | + | * //N/A// |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | == Return Value == |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:Boolean |
| - | | shape | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]]<!-- ThinkGeo.MapSuite.PortableCore.BaseShape --> | The shape you wish to update in the transaction. The Id of the Shape should be the feature Id which you wish to update. | | + | * Description:N/A |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Parameters == |
| - | [[#Public Methods|Go Back]] | + | * //obj// |
| - | ==== Update(Feature) ==== | + | * Type:Object |
| - | This method updates a Feature in an existing transaction. | + | * Description:N/A |
| - | === Overloads === | + | |
| - | This overload allows you pass in a Feature. | + | |
| - | === Remarks === | + | |
| - | This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | <div newline></div> |
| + | ** {{wiki:PublicMethod.gif|}} GetHashCode() ** | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | * //N/A// |
| + | == Remarks == | ||
| + | * //N/A// | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | == Return Value == |
| + | * Type:Int32 | ||
| + | * Description:N/A | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | == Parameters == |
| + | <div newline></div> | ||
| + | ** {{wiki:PublicMethod.gif|}} GetType() ** | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | * //N/A// |
| - | === Return Value === | + | == Remarks == |
| - | ^ Return Type ^ Description ^ | + | * //N/A// |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | == Return Value == |
| - | ^ Name ^ Type ^ Description ^ | + | * Type:Type |
| - | | feature | [[ThinkGeo.MapSuite.PortableCore.Feature|Feature]]<!-- ThinkGeo.MapSuite.PortableCore.Feature --> | The Feature you wish to update in the transaction. | | + | * Description:N/A |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | == Parameters == |
| - | [[#Public Methods|Go Back]] | + | <div newline></div> |
| - | ==== Update(BaseShape, Dictionary<String, String>) ==== | + | ==== Protected Methods ==== |
| - | This method updates a Feature in an existing transaction. | + | ** {{wiki:ProtectedMethod.gif|}} Finalize() ** |
| - | === Overloads === | + | |
| - | This overload allows you to pass in a shape and the columnValues to the Feature it will update. | + | |
| - | === Remarks === | + | |
| - | This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. | + | |
| - | The Transaction System | + | * //N/A// |
| + | == Remarks == | ||
| + | * //N/A// | ||
| - | The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. | + | == Return Value == |
| + | * Type:Void | ||
| + | * Description:N/A | ||
| - | In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | == Parameters == |
| + | <div newline></div> | ||
| + | ** {{wiki:ProtectedMethod.gif|}} MemberwiseClone() ** | ||
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | * //N/A// |
| + | == Remarks == | ||
| + | * //N/A// | ||
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | == Return Value == |
| - | === Return Value === | + | * Type:Object |
| - | ^ Return Type ^ Description ^ | + | * Description:N/A |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | == Parameters == |
| - | ^ Name ^ Type ^ Description ^ | + | <div newline></div> |
| - | | shape | [[ThinkGeo.MapSuite.PortableCore.BaseShape|BaseShape]]<!-- ThinkGeo.MapSuite.PortableCore.BaseShape --> | The shape you wish to update in the transaction. The Id of the Shape should be the feature id which you wish to update. | | + | ==== Public Properties ==== |
| - | | columnValues | Dictionary<String,String><!-- System.Collections.Generic.Dictionary{System.String,System.String} --> | The column values you wish to update in the transaction. | | + | ** {{wiki:PublicProperty.gif|}} IsInTransaction ** |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | * //This property returns true if the FeatureLayer is in a transaction and false if it is not.// |
| - | [[#Public Methods|Go Back]] | + | == Remarks == |
| - | ===== Protected Methods ===== | + | * //To enter a transaction, you must first call the BeginTransaction method of the FeatureLayer. It is possible that some FeatureLayers are read only and do not allow edits. To end a transaction, you must either call CommitTransaction or RollbackTransaction.// |
| - | ==== Finalize() ==== | + | == Return Value == |
| - | === Return Value === | + | * Type:Boolean |
| - | ^ Return Type ^ Description ^ | + | |
| - | | Void<!-- System.Void --> | | | + | |
| - | === Parameters === | + | ** {{wiki:PublicProperty.gif|}} IsTransactionLive ** |
| - | ^ Name ^ Type ^ Description ^ | + | |
| - | <!-- System.Object --> | + | * //This property returns true if the features currently modified in a transaction are expected to reflect their state when calling other methods on the FeatureLayer, such as spatial queries.// |
| - | [[#Protected Methods|Go Back]] | + | == Remarks == |
| - | ==== MemberwiseClone() ==== | + | * //The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.// |
| - | === Return Value === | + | == Return Value == |
| - | ^ Return Type ^ Description ^ | + | * Type:Boolean |
| - | | Object<!-- System.Object --> | | | + | |
| - | === Parameters === | + | ** {{wiki:PublicProperty.gif|}} IsEditable ** |
| - | ^ Name ^ Type ^ Description ^ | + | |
| - | <!-- System.Object --> | + | * //This property returns whether the FeatureLayer allows edits or is read only.// |
| - | [[#Protected Methods|Go Back]] | + | == Remarks == |
| - | ===== Public Properties ===== | + | * //This property is useful to check if a specific FeatureLayer accepts editing. If you call BeginTransaction and this property is false, then an exception will be raised.// |
| - | ==== IsEditable ==== | + | == Return Value == |
| - | This property returns whether the FeatureLayer allows edits or is read only. | + | * Type:Boolean |
| - | === Remarks === | + | |
| - | This property is useful to check if a specific FeatureLayer accepts editing. If you call BeginTransaction and this property is false, then an exception will be raised. | + | |
| - | === Return Value === | + | |
| - | ^ Return Type ^ | + | |
| - | | Boolean<!-- System.Boolean --> | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | ** {{wiki:PublicProperty.gif|}} TransactionBuffer ** |
| - | [[#Public Properties|Go Back]] | + | |
| - | ==== IsInTransaction ==== | + | |
| - | This property returns true if the FeatureLayer is in a transaction and false if it is not. | + | |
| - | === Remarks === | + | |
| - | To enter a transaction, you must first call the BeginTransaction method of the FeatureLayer. It is possible that some FeatureLayers are read only and do not allow edits. To end a transaction, you must either call CommitTransaction or RollbackTransaction. | + | |
| - | === Return Value === | + | |
| - | ^ Return Type ^ | + | |
| - | | Boolean<!-- System.Boolean --> | | + | |
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | * //This property allows you get and set the transaction buffer.// |
| - | [[#Public Properties|Go Back]] | + | == Remarks == |
| - | ==== IsTransactionLive ==== | + | * //N/A// |
| - | This property returns true if the features currently modified in a transaction are expected to reflect their state when calling other methods on the FeatureLayer, such as spatial queries. | + | == Return Value == |
| - | === Remarks === | + | * Type:[[ThinkGeo.MapSuite.Core.TransactionBuffer|TransactionBuffer]] |
| - | The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. | + | |
| - | As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. | + | ==== Protected Properties ==== |
| - | + | ==== Public Events ==== | |
| - | In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes. | + | |
| - | === Return Value === | + | |
| - | ^ Return Type ^ | + | |
| - | | Boolean<!-- System.Boolean --> | | + | |
| - | + | ||
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | |
| - | [[#Public Properties|Go Back]] | + | |
| - | ==== TransactionBuffer ==== | + | |
| - | This property allows you get and set the transaction buffer. | + | |
| - | === Return Value === | + | |
| - | ^ Return Type ^ | + | |
| - | | [[ThinkGeo.MapSuite.PortableCore.TransactionBuffer|TransactionBuffer]]<!-- ThinkGeo.MapSuite.PortableCore.TransactionBuffer --> | | + | |
| - | + | ||
| - | <!-- ThinkGeo.MapSuite.PortableCore.EditTools --> | + | |
| - | [[#Public Properties|Go Back]] | + | |
| - | ===== Protected Properties ===== | + | |
| - | ===== Public Events ===== | + | |
| - | __NOTOC__ | + | |
| - | [[Category:MapSuitePortableCore]] | + | |
| - | [[Category:ThinkGeo.MapSuite.PortableCore]] | + | |
| - | [[Category:UpdateDocumentation]] | + | |
thinkgeo.mapsuite.portablecore.edittools.1440040132.txt.gz · Last modified: 2015/09/21 08:07 (external edit)