public void AddCategory(ModelCategory newCategory)
{
int nLastedId = -1;
string sQuery = @"INSERT INTO TB_CATEGORY (PID,PRJID,CODE,DISPNM,DESCRPT,CREATED,UPDATED)
VALUES (@PID ,@PRJID ,@CODE ,@DISPNM ,@DESCRPT ,GETDATE() ,NULL)
SELECT IDENT_CURRENT('TB_CATEGORY')";
UDataQuerySet set = new UDataQuerySet(sQuery);
set.AddParam("@PID", newCategory.ParentId);
set.AddParam("@PRJID", newCategory.ProjectId);
set.AddParam("@CODE", newCategory.Code);
set.AddParam("@DISPNM", newCategory.DisplayName);
set.AddParam("@DESCRPT", newCategory.Description);
try
{
nLastedId = m_agent.GetValue <int>(set);
newCategory.Id = nLastedId;
}
catch (Exception ex)
{
log.Error(ex);
newCategory.Id = -1;
}
}
public void SetupCategory()
{
m_nCategory = ModelCategory.MC_PLAYER;
string str = m_szPath.ToLower();
if (str.IndexOf("player/") > 0)
{
m_nCategory = ModelCategory.MC_PLAYER;
}
else if (str.IndexOf("monster/") > 0)
{
m_nCategory = ModelCategory.MC_MONSTER;
}
else if (str.IndexOf("npc/") > 0)
{
m_nCategory = ModelCategory.MC_NPC;
}
else if (str.IndexOf("weapons/") > 0)
{
m_nCategory = ModelCategory.MC_WEAPON;
}
else if (str.IndexOf("sfx/") > 0)
{
m_nCategory = ModelCategory.MC_SFX;
}
else if (str.IndexOf("mapobject/") > 0)
{
m_nCategory = ModelCategory.MC_MAP_OBJECT;
}
}
public List <ModelCategory> GetAllCategory(ModelProject selectedProject)
{
List <ModelCategory> aryResult = new List <ModelCategory>();
DataTable tbResult = null;
UDataQuerySet set = new UDataQuerySet("SP_CAT_SELECT", CommandType.StoredProcedure);
set.AddParam("@PRJID", selectedProject.ID);
try
{
tbResult = m_agent.GetDataTable(set);
foreach (DataRow row in tbResult.Rows)
{
ModelCategory category = new ModelCategory();
category.WriteData(row);
aryResult.Add(category);
}
}
catch (Exception ex)
{
log.Error(ex);
}
finally
{
if (tbResult != null)
{
tbResult.Dispose();
}
}
return(aryResult);
}
private void List_Category_ItemLongClick(object sender, AdapterView.ItemLongClickEventArgs e)
{
item = list_name_category[e.Position];
var popupMenu = new PopupMenu(this, e.View);
try
{
var fields = popupMenu.Class.GetDeclaredFields();
foreach (Field field in fields)
{
if ("mPopup".Equals(field.Name))
{
field.Accessible = true;
Java.Lang.Object menuPopupHelper = field.Get(popupMenu);
Method setForceIcons = menuPopupHelper.Class.GetDeclaredMethod("setForceShowIcon", Java.Lang.Boolean.Type);
setForceIcons.Invoke(menuPopupHelper, true);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
popupMenu.Inflate(Resource.Layout.menu_itemlistcategoty);
popupMenu.Show();
popupMenu.MenuItemClick += PopupMenu_MenuItemClick;
}
private void InitilizeAttribute(Constants.Master enumMaster)
{
try
{
switch (enumMaster)
{
case Constants.Master.Category:
_categoryView = (ICategoryView)_view;
_modelCat = new ModelCategory();
break;
case Constants.Master.SubCategory:
_masterListEntry = (ISubCategoryView)_view;
_modelSubCat = new ModelSubCategory();
break;
default:
break;
}
}
catch (Exception ex)
{
throw ex;
}
}
internal void SetCategory(ModelCategory category)
{
SelectedCategory = category;
if (OnSelectedCategoryChanged != null)
{
OnSelectedCategoryChanged(category);
}
}
void Category_OnSelectedCategoryChanged(ModelCategory model)
{
if (cmbPath.Items.Count > 0)
{
int nIndex = cmbPath.Items.IndexOf(model);
cmbPath.SelectedIndex = nIndex;
}
}
public ActionResult DeleteConfirmed(int id)
{
ModelCategory modelCategory = db.ModelCategories.Find(id);
db.ModelCategories.Remove(modelCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// 设置相关分组代码
/// </summary>
/// <param name="code">分组代码</param>
/// <param name="cascadeEntity">是否级联显示</param>
public void SetGroupCode(string code, bool cascadeEntity = false)
{
// load all groups include children
this.relateGroups = CallerFactory <IGroupService> .Instance.FindWithChildrenByCode(code).ToList();
if (this.relateGroups.Count == 0)
{
throw new PoseidonException(ErrorCode.ObjectNotFound);
}
var top = relateGroups.Find(r => r.Code == code);
this.modelCategory = CallerFactory <IGroupService> .Instance.GetCategory(top);
var groupItems = CallerFactory <IGroupService> .Instance.FindAllItems(top.Id).ToList();
var ids = groupItems.Select(r => r.EntityId).ToList();
switch (modelCategory)
{
case ModelCategory.Organization:
this.relateOrganizations = CallerFactory <IOrganizationService> .Instance.FindWithIds(ids).ToList();
break;
case ModelCategory.Building:
this.relateBuildings = CallerFactory <IBuildingService> .Instance.FindWithIds(ids).ToList();
break;
case ModelCategory.File:
this.relateFiles = CallerFactory <IFileService> .Instance.FindWithIds(ids).ToList();
break;
case ModelCategory.Facility:
this.relateFacilities = CallerFactory <IFacilityService> .Instance.FindWithIds(ids).ToList();
break;
}
this.cascadeEntity = cascadeEntity;
this.tlGroup.BeginUnboundLoad();
this.tlGroup.ClearNodes();
var topNode = this.tlGroup.AppendNode(new object[] { top.Id, top.Name, 1 }, null);
topNode.StateImageIndex = 0;
topNode.HasChildren = true;
var children = this.relateGroups.Where(r => r.ParentId == top.Id).ToList();
AppendGroupNodes(children, topNode);
topNode.Expanded = true;
this.tlGroup.EndUnboundLoad();
}
public async Task <InvokeResult> UpdateModelCategoryAsync(ModelCategory model, EntityHeader org, EntityHeader user)
{
await AuthorizeAsync(model, AuthorizeResult.AuthorizeActions.Update, user, org);
var result = Validator.Validate(model, Actions.Update);
await _repo.UpdateModelCategoryAsync(model);
return(result.ToInvokeResult());
}
internal void Remove(ModelCategory selectedCategory)
{
DacFactory.Current.Category.DelCategot(selectedCategory);
selectedCategory.Parent.Childs.Remove(selectedCategory);
if (OnCategoryDeleted != null)
{
OnCategoryDeleted(selectedCategory);
}
}
public EditKategoriPage(string token, ModelCategory modelCategory)
{
this.token = token;
this.modelCategory = modelCategory;
InitializeComponent();
initUIBuilders();
initUIElements();
setController(new CategoryController(this));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
ModelCategory modelCategory = await db.ModelCategories.FindAsync(id);
db.ModelCategories.Remove(modelCategory);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <InvokeResult> AddModelCategoryAsync(ModelCategory modelCategory, EntityHeader org, EntityHeader user)
{
ValidationCheck(modelCategory, Actions.Create);
await AuthorizeAsync(modelCategory, AuthorizeResult.AuthorizeActions.Create, user, org);
await _repo.AddModelCategoryAsync(modelCategory);
return(InvokeResult.Success);
}
public TreeNodeCategory(ModelCategory category)
: base()
{
m_curValue = category;
nodeEntry.Key = category.Id;
nodeEntry.Value = category;
this.Tag = category;
category_OnRefreshed(category);
category.OnRefreshed += category_OnRefreshed;
}
private void contextMenuStrip1_Opening(object sender, CancelEventArgs e)
{
menuItemReorder.Enabled = true;
ModelCategory category = DataManager.Current.Category.SelectedCategory;
if (category == null || category.ParentId == -1 || DataManager.Current.Requirement.SelectedRequirements.Count == 0)
{
menuItemReorder.Enabled = false;
}
}
internal void DeleteCategory(ModelCategory selectedCategory)
{
List <ModelReqmnt> aryReqs = Requirement.FindAll(selectedCategory.Id);
foreach (ModelReqmnt req in aryReqs)
{
req.Category = Category.ETC;
}
Category.Remove(selectedCategory);
}
public async Task <ActionResult> Edit([Bind(Include = "Id,CategoryName")] ModelCategory modelCategory)
{
if (ModelState.IsValid)
{
db.Entry(modelCategory).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(modelCategory));
}
private void UpdateSelectedRequirements(ModelCategory category)
{
List <ModelCategory> aryAllChildCategories = m_parent.Category.GetAllChildCategories(category.Id);
SelectedRequirements.Clear();
foreach (ModelCategory curCategory in aryAllChildCategories)
{
List <ModelReqmnt> aryRequirement = m_aryAllRequirements.FindAll(m => m.CategoryId == curCategory.Id);
SelectedRequirements.AddRange(aryRequirement);
}
}
private void PopulateCategory(TreeNode current)
{
ModelCategory curModel = (ModelCategory)current.Tag;
foreach (ModelCategory childModel in curModel.Childs)
{
TreeNode childNode = new TreeNodeCategory(childModel);
current.Nodes.Add(childNode);
PopulateCategory(childNode);
}
}
public ActionResult Edit([Bind(Include = "ModelID,BrandID,ModelName")] ModelCategory modelCategory)
{
if (ModelState.IsValid)
{
db.Entry(modelCategory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.BrandID = new SelectList(db.Brands, "BrandID", "BrandName", modelCategory.BrandID);
return(View(modelCategory));
}
public ActionResult Create([Bind(Include = "ModelID,BrandID,ModelName")] ModelCategory modelCategory)
{
if (ModelState.IsValid)
{
db.ModelCategories.Add(modelCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.BrandID = new SelectList(db.Brands, "BrandID", "BrandName", modelCategory.BrandID);
return(View(modelCategory));
}
public async Task <ActionResult> Create([Bind(Include = "Id,CategoryName")] ModelCategory modelCategory)
{
if (ModelState.IsValid)
{
db.ModelCategories.Add(modelCategory);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(modelCategory));
}
void category_OnRefreshed(ModelCategory category)
{
if (TreeView != null && TreeView.InvokeRequired)
{
TreeView.Invoke(new ModelCategory.OnRefreshedHandler(category_OnRefreshed), category);
}
else
{
this.Text = category.Code;
this.ToolTipText = category.DisplayName;
}
}
internal void ChangeCategory(ModelCategory targetModel, List <ModelReqmnt> aryRequirements)
{
foreach (ModelReqmnt req in aryRequirements)
{
req.Category = targetModel;
}
UpdateSelectedRequirements(targetModel);
if (OnUpdateRequirements != null)
{
OnUpdateRequirements();
}
}
internal void AddCategory(ModelCategory modelParentCategory, ModelCategory modelCategory)
{
AllCategories.Add(modelCategory);
modelParentCategory.Childs.Add(modelCategory);
modelCategory.Parent = modelParentCategory;
DacFactory.Current.Category.AddCategory(modelCategory);
if (OnCategoryAdded != null)
{
OnCategoryAdded(modelCategory);
}
}
private void btnOK_Click(object sender, EventArgs e)
{
int nSelectedIndex = cmbPath.SelectedIndex;
ModelCategory category = (ModelCategory)cmbPath.Items[nSelectedIndex];
CurRequirement.Category = category;
CurRequirement.Index = Convert.ToInt32(txtIndex.Text);
CurRequirement.Requirement = txtRequirements.Text;
DataManager.Current.Requirement.Save(CurRequirement);
this.Close();
}
private void MakeHeirachy(ModelCategory curCategory)
{
if (curCategory != null)
{
List <ModelCategory> aryChildren = FindAllByParentID(curCategory.Id);
foreach (ModelCategory child in aryChildren)
{
curCategory.Childs.Add(child);
child.Parent = curCategory;
MakeHeirachy(child);
}
}
}
// GET: ModelCategories/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ModelCategory modelCategory = db.ModelCategories.Find(id);
if (modelCategory == null)
{
return(HttpNotFound());
}
return(View(modelCategory));
}
private void treeCategory_ItemDrag(object sender, ItemDragEventArgs e)
{
if (e.Item is TreeNode)
{
TreeNode node = (TreeNode)e.Item;
ModelCategory category = (ModelCategory)node.Tag;
if ("ROOT".Equals(category.Code) || "ETC".Equals(category.Code))
{
return;
}
DoDragDrop(e.Item, DragDropEffects.Move);
}
}
//String/enum modelName;
// An object on one or all of the maps loaded when this object is created
public FbxModel(String name, ContentManager content, MapName mapname, ModelCategory category)
{
mapName = mapname;
this.category = category;
//Load the model
model = content.Load<Model>("Models/Maps/" + name);//Takes a long time for large models. estimate 4 seconds per 1MB fbx.
#if !DEBUG
Utils.fixNullLightDirections(model);
#endif
GC.Collect();
//sets scale and position of model from fbx file
transforms = new Matrix[model.Bones.Count];
model.CopyAbsoluteBoneTransformsTo(transforms);
}
public static void addMapToPhysics(Model model, ModelCategory category)
{
if (category == ModelCategory.Track || category == ModelCategory.Wall || category == ModelCategory.InvisibleWall)
{
Vector3[] vertices;
int[] indices;
GetVerticesAndIndicesFromModelPipeline(model, out vertices, out indices);
StaticMesh physicsMesh = new StaticMesh(vertices, indices);
if (category == ModelCategory.Wall)
{
//physicsMesh.Material.KineticFriction = 0.9f;//Improves wall collisions by slowing ship down
//physicsMesh.Material.StaticFriction = 0.9f;//Improves wall collisions by slowing ship down
//physicsMesh.Material.Bounciness = 0;
physicsMesh.CollisionRules.Personal = CollisionRule.NoSolver;
physicsMesh.Sidedness = BEPUphysics.CollisionShapes.ConvexShapes.TriangleSidedness.Counterclockwise;//Only collide with the outside of walls.
currentTrackWall = physicsMesh;
}
if (category == ModelCategory.InvisibleWall)
{
physicsMesh.CollisionRules.Personal = CollisionRule.NoSolver;
currentTrackInvisibleWall = physicsMesh;
}
if (category == ModelCategory.Track)
{
physicsMesh.Material.Bounciness = 0.3f;
physicsMesh.Material.KineticFriction = 0.1f;
physicsMesh.CollisionRules.Personal = CollisionRule.NoSolver;//No collisions with track
//CollisionGroup noSelfCollideGroup = new CollisionGroup();
currentTrackFloor = physicsMesh;
// currentTrackFloor.Events.InitialCollisionDetected += new BEPUphysics.NarrowPhaseSystems.CollisionInformations.Events.InitialCollisionDetectedEventHandler<Entity>(trackCollisionFn);
}
currentPhysicsObjects.Add(physicsMesh);
Physics.space.Add(physicsMesh);
}
}
