702 lines
22 KiB
C#
702 lines
22 KiB
C#
/*********************************************************************************************
|
|
* Copyright 2004 - Volian Enterprises, Inc. All rights reserved.
|
|
* Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
|
|
* ------------------------------------------------------------------------------
|
|
* $Workfile: Plant.cs $ $Revision: 10 $
|
|
* $Author: Jsj $ $Date: 10/20/06 9:34a $
|
|
*
|
|
* $History: Plant.cs $
|
|
*
|
|
* ***************** Version 10 *****************
|
|
* User: Jsj Date: 10/20/06 Time: 9:34a
|
|
* Updated in $/LibSource/VEObject
|
|
* long name fix
|
|
*
|
|
* ***************** Version 9 *****************
|
|
* User: Jsj Date: 9/26/06 Time: 9:38a
|
|
* Updated in $/LibSource/VEObject
|
|
* check for a siingle quote in directory name
|
|
*
|
|
* ***************** Version 8 *****************
|
|
* User: Kathy Date: 6/06/05 Time: 12:35p
|
|
* Updated in $/LibSource/VEObject
|
|
* Allow lock set even if system lock set
|
|
*
|
|
* ***************** Version 7 *****************
|
|
* User: Kathy Date: 4/12/05 Time: 1:01p
|
|
* Updated in $/LibSource/VEObject
|
|
*
|
|
* ***************** Version 6 *****************
|
|
* User: Kathy Date: 2/02/05 Time: 10:13a
|
|
* Updated in $/LibSource/VEObject
|
|
* B2005-006: fix missing proc sets under plant
|
|
*
|
|
* ***************** Version 5 *****************
|
|
* User: Kathy Date: 1/31/05 Time: 11:06a
|
|
* Updated in $/LibSource/VEObject
|
|
* Fix B2005-005 (connection & delete directory errors). also, fix icon
|
|
* usage & security for new
|
|
*
|
|
* ***************** Version 4 *****************
|
|
* User: Kathy Date: 1/24/05 Time: 2:45p
|
|
* Updated in $/LibSource/VEObject
|
|
* B2005-004 fixes
|
|
*
|
|
* ***************** Version 3 *****************
|
|
* User: Kathy Date: 1/14/05 Time: 10:38a
|
|
* Updated in $/LibSource/VEObject
|
|
* B2004-061: Fix security optoins
|
|
*
|
|
* ***************** Version 2 *****************
|
|
* User: Kathy Date: 1/10/05 Time: 12:58p
|
|
* Updated in $/LibSource/VEObject
|
|
* B2004-063 fix
|
|
*
|
|
* ***************** Version 1 *****************
|
|
* User: Kathy Date: 7/27/04 Time: 8:53a
|
|
* Created in $/LibSource/VEObject
|
|
*********************************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.ComponentModel;
|
|
using Utils;
|
|
using VENetwork;
|
|
|
|
namespace VEObject
|
|
{
|
|
/// <summary>
|
|
/// This defines the VEO_Plant class which handles plant data. This contains
|
|
/// support for the vexxx layer.
|
|
/// </summary>
|
|
public class VEO_Plant : VEO_Base
|
|
{
|
|
public long accessFlags;
|
|
protected string tmpTitle;
|
|
protected string tmpLocation;
|
|
protected bool changeLocation;
|
|
protected bool changeTitle;
|
|
private string PrevDirectory;
|
|
public VEO_Plant(UserRunTime iusrRunTime, string ititle, string ipath)
|
|
{
|
|
// iconStates are the imagelist indexes for the tree view (imglist1)
|
|
// the states are Nolock, LockedByMe, LockedByOther, LockPending, Empty.
|
|
iconStates = new int[5] {3,21,5,22,4};
|
|
_Title = ititle;
|
|
_Location = ipath;
|
|
usrRunTime = iusrRunTime;
|
|
changeLocation=false;
|
|
changeTitle=false;
|
|
IsEmpty=false;
|
|
VEObjectType=(int)VEObjectTypesDefs.Plant;
|
|
isNew=false;
|
|
LoadLockInfo();
|
|
icon = iconStates[(int)Lock.LockStatus];
|
|
if (Lock.LockStatus != VENetwork.Status.LockedByOther)
|
|
{
|
|
if (ipath != null)
|
|
{
|
|
string[] dirs = new string[40];
|
|
dirs = Directory.GetDirectories(ipath);
|
|
if (dirs.Length == 0)
|
|
{
|
|
IsEmpty=true;
|
|
//only reset the icon to empty if there is no lock icon.
|
|
//if a lock, show the lock icon
|
|
if (Lock.LockStatus == VENetwork.Status.NoLock) icon = iconStates[(int)VEO_IconStates.Empty];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void LoadLockInfo()
|
|
{
|
|
Lock = new VELock(_Location, usrRunTime.myUserData, usrRunTime.InMultiUserMode?VENetwork.LockTypes.Plant:VENetwork.LockTypes.None);
|
|
}
|
|
|
|
// Properties used for modify of 'Properties' from File menu.
|
|
[Description("Location"),Category("Plant"),ReadOnly(true)]public string Location
|
|
{
|
|
get{return _Location;}
|
|
set{_Location=value;}
|
|
}
|
|
|
|
[Description("Title"),Category("Plant")]public string Title
|
|
{
|
|
get
|
|
{
|
|
if (!changeTitle)
|
|
return _Title;
|
|
else
|
|
return tmpTitle;
|
|
}
|
|
set
|
|
{
|
|
changeTitle=true;
|
|
tmpTitle=value;
|
|
}
|
|
}
|
|
|
|
// The open method checks for multi-user settings at the plant level. It
|
|
// also positions into the plant directory.
|
|
public override bool Open()
|
|
{
|
|
isOpen = true;
|
|
PrevDirectory = Directory.GetCurrentDirectory();
|
|
if(_Location!=null)Directory.SetCurrentDirectory(_Location);
|
|
if (Connection!=null)Connection.Enter(false);
|
|
return true;
|
|
}
|
|
|
|
// The close method resets, if necessary from any multi-user settings and
|
|
// positions back to the datapath directory (which is a level above the
|
|
// current level)
|
|
public override bool Close()
|
|
{
|
|
if (!isOpen)return false;
|
|
isOpen=false;
|
|
if (Connection!=null)Connection.Exit();
|
|
Directory.SetCurrentDirectory("..");
|
|
return true;
|
|
}
|
|
|
|
public override void Restore()
|
|
{
|
|
changeTitle=false;
|
|
}
|
|
|
|
public override bool Delete()
|
|
{
|
|
DialogResult result = MessageBox.Show("Are you sure you want to delete the entire plant directory " + this._Location,"Confirm Delete Again",MessageBoxButtons.YesNoCancel);
|
|
if (result == DialogResult.Yes)
|
|
{
|
|
// delete the entire directory
|
|
if (Directory.Exists(this._Location))
|
|
{
|
|
if(isOpen)Close();
|
|
try
|
|
{
|
|
Directory.Delete(this._Location,true);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Could not delete directory - manually delete " + this._Location + ". Cause: " + e.Message);
|
|
}
|
|
if (Directory.Exists(this._Location))
|
|
{
|
|
MessageBox.Show("Unable to delete the plant directory.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void CreateProcSet(string dirpath, XmlElement nm, string dirname, long flags)
|
|
{
|
|
// see if there is a title file in the directory and use
|
|
// it if there is, otherwise use menuname & if there's no menu
|
|
// name, use the directory name.
|
|
VEO_ProcSet procset = null;
|
|
string titlepath = dirpath + "\\" + "Title";
|
|
FileInfo fi = new FileInfo(titlepath);
|
|
if (File.Exists(titlepath))
|
|
{
|
|
StreamReader myReader = new StreamReader(titlepath);
|
|
titlepath = myReader.ReadLine();
|
|
myReader.Close();
|
|
procset = new VEO_ProcSet(usrRunTime, titlepath.Trim(), dirpath, flags);
|
|
}
|
|
else
|
|
{
|
|
if (nm != null)
|
|
procset = new VEO_ProcSet(usrRunTime, nm.InnerText, dirpath, flags);
|
|
else
|
|
{
|
|
string tmpdirnm = dirname;
|
|
int indx=0;
|
|
// if this is temp change directory, tack on text to recognize it
|
|
if ((indx=dirpath.ToUpper().IndexOf("TMPCHG"))>-1)
|
|
tmpdirnm = dirname + " - Temporary Change Version";
|
|
// if this is approved, tack on Current Approved Version to the title
|
|
else if ((indx=dirpath.ToUpper().IndexOf("APPROVED"))>-1)
|
|
tmpdirnm = dirname + " - Current Approved Version";
|
|
procset = new VEO_ProcSet(usrRunTime, tmpdirnm, dirpath,flags);
|
|
}
|
|
}
|
|
procset.parentObj = this;
|
|
Children.Add(procset);
|
|
}
|
|
|
|
// private method, used below, to add a directory to the child list
|
|
// (list contains proc sets)
|
|
private bool ProcessDirName(XmlElement par, string dirname, int plntsecindx)
|
|
{
|
|
XmlNodeList nodeList = par.SelectNodes("ProcFile");
|
|
if (nodeList == null) return false;
|
|
|
|
foreach (XmlNode dirnd in nodeList)
|
|
{
|
|
XmlElement dele=(XmlElement)dirnd;
|
|
string dirpath = _Location + "\\" + dirname;
|
|
if (File.Exists(dirpath+"\\"+dirnd.InnerText))
|
|
{
|
|
//
|
|
// see if there's an exception or a requirement, i.e. use
|
|
// the Working Draft if there's no proc2 directory (Except)
|
|
// or use the Working Draft Unit 1 if there's a proc2
|
|
// directory (Require)
|
|
bool excpt = false;
|
|
bool req = true;
|
|
string path1=null;
|
|
XmlElement except = (XmlElement) par.SelectSingleNode("Exception");
|
|
if (except != null)
|
|
{
|
|
// if this exception directory exists, don't add this to
|
|
// the set.
|
|
|
|
path1 = dirpath + "\\" + except.InnerText;
|
|
if (Directory.Exists(path1)) excpt = true;
|
|
}
|
|
XmlElement require = (XmlElement) par.SelectSingleNode("Require");
|
|
if (require != null)
|
|
{
|
|
// if this require directory exists, add this to set only
|
|
// if this exists.
|
|
path1 = dirpath + "\\" + require.InnerText;
|
|
if (Directory.Exists(path1) == false) req = false;
|
|
}
|
|
if (excpt == false && req == true)
|
|
{
|
|
XmlElement nm = (XmlElement) par.SelectSingleNode("MenuName");
|
|
long flags=0L;
|
|
// bug fix B2006-045
|
|
// need to convert long folder/file names to short (8.3)
|
|
ShortName sname = new ShortName(dirpath);
|
|
bool hasSec = usrRunTime.sec.ProcSetHasSecurity(plntsecindx, Path.GetFileName(sname.ShortFileName));
|
|
// bool hasSec = usrRunTime.sec.ProcSetHasSecurity(plntsecindx, dirname);
|
|
if (this.usrRunTime.sec==null) flags=Security.SUPERACCESS;
|
|
else if (hasSec) flags = usrRunTime.sec.GetProcSecurity(sname.ShortFileName);
|
|
// else if (hasSec) flags = usrRunTime.sec.GetProcSecurity(dirpath);
|
|
|
|
if((hasSec && flags!=0L) || (!hasSec&&!usrRunTime.sec.BlockAccess()))
|
|
{
|
|
CreateProcSet(dirpath, nm, dirname, flags);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// This method processes through the SubDirSearch xmlelement tree in
|
|
// menuwin2.xml to see if the input procedure set directory has valid
|
|
// procedure set subdirectories. Arguments are:
|
|
// subtop is xmlelement for the SubDirSearch in menuwin2.xml, dir is actual
|
|
// procset directory name (for example, procs, proc000.dvt, etc) and
|
|
// dname is the name to be used for the directory name in the menuwin2.xml
|
|
// file under the SubDirSearch xmlelement tree (for example, procs, *.dvt, etc)
|
|
private bool ProcessSubDir(XmlElement subtop, string dri, string dname, int plntsecindx)
|
|
{
|
|
XmlNodeList nodeList;
|
|
string xp = "descendant::ProcSet[Dir = \'" + dname + "\']";
|
|
|
|
try
|
|
{
|
|
nodeList = subtop.SelectNodes(xp);
|
|
// for each possible subdirectory for this directory, see if it
|
|
// exists.
|
|
foreach (XmlNode subdirname in nodeList)
|
|
{
|
|
XmlElement subdele=(XmlElement)subdirname;
|
|
XmlNodeList FnodeList = subdirname.SelectNodes("ProcFile");
|
|
// see if the files listed exist, if so, add them to the
|
|
// plant procset list.
|
|
foreach (XmlNode dirnd in FnodeList)
|
|
{
|
|
XmlElement dele=(XmlElement)dirnd;
|
|
string dirpath = _Location + "\\" + dri;
|
|
if (File.Exists(dirpath+"\\"+dirnd.InnerText))
|
|
{
|
|
XmlElement nm = (XmlElement) subdirname.SelectSingleNode("MenuName");
|
|
string subdir = dirnd.InnerText.Substring(0,dirnd.InnerText.LastIndexOf("\\"));
|
|
|
|
long flags=0L;
|
|
bool hasSec = usrRunTime.sec.ProcSetHasSecurity(plntsecindx, dri+"\\"+subdir);
|
|
if (this.usrRunTime.sec==null) flags=Security.SUPERACCESS;
|
|
else if (hasSec) flags = usrRunTime.sec.GetProcSecurity(dirpath + "\\" + subdir);
|
|
|
|
if((hasSec && flags!=0L) || (!hasSec&&!usrRunTime.sec.BlockAccess()))
|
|
CreateProcSet(dirpath+"\\"+subdir, nm, dri, flags);
|
|
}
|
|
break; // out of file check foreach
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show(e.Message);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Using the menuwin2.xml file, read in child list by seeing which
|
|
// directories (proc sets) are contained in this vexxx directory.
|
|
public override bool Read(bool ChkForChldOnly)
|
|
{
|
|
bool didone;
|
|
Cursor.Current = Cursors.WaitCursor;
|
|
|
|
// using the . Then do exist tests to see if they
|
|
// exist on this datapath.
|
|
usrRunTime.LoadMenuWin2();
|
|
XmlDocument xmldoc = usrRunTime.menuwin2XML.GetXmlDoc();
|
|
|
|
XmlElement top = (XmlElement) xmldoc.FirstChild;
|
|
XmlElement sys = (XmlElement) top.SelectSingleNode("PlantAttach");
|
|
XmlElement subtop = (XmlElement) top.SelectSingleNode("SubDirSearch");
|
|
|
|
DirectoryInfo cur = new DirectoryInfo(_Location);
|
|
DirectoryInfo[] diArr = cur.GetDirectories();
|
|
int plntsecindx = usrRunTime.sec.GetPlantSecurityIndex(_Location);
|
|
|
|
foreach (DirectoryInfo dri in diArr)
|
|
{
|
|
XmlNodeList nodeList;
|
|
string dname = null;
|
|
int indx;
|
|
if ((indx=dri.Name.IndexOf("."))>-1)
|
|
{
|
|
//must be *.prc, *.bck, *.dvt, *.sl?
|
|
if (indx+4<=dri.Name.Length)
|
|
{
|
|
dname = "*." + dri.Name.Substring(indx+1,3).ToLower();
|
|
if (dname.StartsWith("*.sl"))
|
|
dname = dname.Substring(0,4) + "?";
|
|
}
|
|
else
|
|
dname = null;
|
|
}
|
|
else if ((indx=dri.Name.IndexOf("'"))>-1)
|
|
{
|
|
// bug fix B2006-047
|
|
// if not a .PRC folder, then we get an error looking up
|
|
// the directory name in XML (if it has an ' in the name)
|
|
dname = null;
|
|
}
|
|
else
|
|
{
|
|
dname = dri.Name.ToLower();
|
|
}
|
|
|
|
|
|
if (dname!=null)
|
|
{
|
|
string xp = "descendant::ProcSet[Dir = \'" + dname + "\']";
|
|
|
|
try
|
|
{
|
|
nodeList = sys.SelectNodes(xp);
|
|
foreach (XmlNode dirname in nodeList)
|
|
{
|
|
XmlElement dele=(XmlElement)dirname;
|
|
didone = ProcessDirName(dele, dri.Name, plntsecindx);
|
|
if (Children.Count > 0 && ChkForChldOnly)
|
|
{
|
|
Cursor.Current = Cursors.Default;
|
|
return true;
|
|
}
|
|
// if a directory was found, see if any
|
|
// subdirectories exist that need added too.
|
|
bool didsub = false;
|
|
if (didone) didsub = ProcessSubDir(subtop, dri.Name, dname, plntsecindx);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show(e.Message.ToString());
|
|
Cursor.Current = Cursors.Default;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// if no children, change icon to empty (unless it has a lock icon)
|
|
if (Children.Count <=0 && Lock.LockStatus == VENetwork.Status.NoLock) icon = iconStates[(int)VEO_IconStates.Empty];
|
|
Cursor.Current = Cursors.Default;
|
|
return true;
|
|
}
|
|
|
|
// write out change (modification of title for plant) for plant to
|
|
// the menuwin.xml file
|
|
public override bool Write()
|
|
{
|
|
|
|
string newtitle=null;
|
|
if (changeTitle)
|
|
{
|
|
newtitle = tmpTitle;
|
|
bool success = usrRunTime.ModMenuWin(newtitle, this._Title);
|
|
if (success==false)
|
|
{
|
|
MessageBox.Show("Could not modify title for the plant.");
|
|
return false;
|
|
}
|
|
MessageBox.Show("Please send \\ve-proms\\menuwin & \\ve-proms\\menuwin.xml files to Volian.");
|
|
_Title=newtitle;
|
|
changeTitle=false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// create a new proc set object (child for this plant)
|
|
public override Object MakeNewChild()
|
|
{
|
|
if (!isOpen)Open();
|
|
VEO_ProcSet ps = new VEO_ProcSetN(usrRunTime,null,_Location);
|
|
return ps;
|
|
}
|
|
|
|
// save a new proc set (child for this plant)
|
|
public override bool SaveChild(Object obj)
|
|
{
|
|
VEO_ProcSetN ps = (VEO_ProcSetN) obj;
|
|
|
|
// check for valid child
|
|
bool valid = ps.IsValid();
|
|
if (valid == false) return false;
|
|
|
|
valid = ps.SaveNew("dummy");
|
|
if (valid == true)
|
|
{
|
|
// add this item to this plants list of children.
|
|
Children.Add((VEO_ProcSet)obj);
|
|
ps.parentObj=this;
|
|
ps._Location = this._Location + "\\" + ps._Location;
|
|
ps.icon=iconStates[0];
|
|
// if this plant's icon is 'empty', change it to either lock (if locked),
|
|
// or to not empty.
|
|
icon = iconStates[(int)Lock.LockStatus];
|
|
IsEmpty=false;
|
|
}
|
|
return valid;
|
|
}
|
|
|
|
// save a new plant directory
|
|
public override bool SaveNew(string pth)
|
|
{
|
|
|
|
// check for non-empty data.
|
|
|
|
if (tmpLocation == null || tmpLocation == "" || tmpTitle == null || tmpTitle == "")
|
|
{
|
|
MessageBox.Show("Need to fill in all data.");
|
|
return false;
|
|
}
|
|
// for this new plant, make the directory and write out
|
|
// to the menuwin & menuwin.xml files.
|
|
|
|
// if using the file browser dialog, the drive may be included, if so
|
|
// check that the directory matches the datapath.
|
|
int slash = tmpLocation.LastIndexOf("\\");
|
|
if (slash>0)
|
|
{
|
|
string drvtmp = tmpLocation.Substring(0,slash+1);
|
|
ShortName sname = new ShortName(drvtmp);
|
|
string drv=sname.ShortFileName;
|
|
sname = null;
|
|
if (drv.ToUpper() != pth.ToUpper())
|
|
{
|
|
MessageBox.Show("Invalid path, directory must match datapath");
|
|
return false;
|
|
}
|
|
// remove the drive part of the path, it's added back later.
|
|
tmpLocation = tmpLocation.Substring(slash+1,tmpLocation.Length-(slash+1));
|
|
}
|
|
|
|
// check for ve*
|
|
if (tmpLocation.Substring(0,2).ToUpper() != "VE")
|
|
{
|
|
MessageBox.Show("First two characters must be 'VE' for new plant directory name.");
|
|
return false;
|
|
}
|
|
|
|
// also check that the name is not greater than 8 characters (an old 16-bit hangover)
|
|
if (tmpLocation.Length>8)
|
|
{
|
|
MessageBox.Show("Directory/plant name must be 8 characters or less.");
|
|
return false;
|
|
}
|
|
|
|
// make path to new directory & check for existence.
|
|
string curpath=null;
|
|
curpath = pth + "\\" + this.tmpLocation;
|
|
DirectoryInfo cur = new DirectoryInfo(curpath);
|
|
|
|
if (cur.Exists )
|
|
{
|
|
DirectoryInfo[] di = cur.GetDirectories("*");
|
|
FileInfo[] fi = cur.GetFiles("*");
|
|
if (di.Length>0 || fi.Length>0)
|
|
{
|
|
MessageBox.Show("The plant directory you specified already exists & has contents. Enter a different name.");
|
|
return false;
|
|
}
|
|
}
|
|
// if the directory exists & it is already in the menu file, it didn't succeed
|
|
// in adding the new item.
|
|
if (cur.Exists && (usrRunTime.IsInMenuWin(this.tmpLocation)!=0))
|
|
{
|
|
MessageBox.Show("The plant directory you specified already exists and the plant name exists in the menu files.");
|
|
return false;
|
|
}
|
|
try
|
|
{
|
|
if (cur.Exists == false)cur.Create();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Error creating directory: " + e.Message);
|
|
return false;
|
|
}
|
|
|
|
// now add to end of menuwin & menuwin.xml.
|
|
bool success = usrRunTime.AddToMenuWin(this.tmpTitle,this.tmpLocation);
|
|
if (success==false)
|
|
{
|
|
MessageBox.Show("Could not add directory to ve-proms menuing files. Could not create plant directory.");
|
|
cur.Delete();
|
|
return false;
|
|
}
|
|
MessageBox.Show("The VE-PROMS Security Access Module (VESAM) may need to be used to set permissions to access the new plant.");
|
|
_Title=tmpTitle;
|
|
_Location=tmpLocation;
|
|
changeTitle=false;
|
|
changeLocation=false;
|
|
// set a security flag for this. Cases could be that there is no security in vesam,
|
|
// that it has security in vesam, though it didn't exist for this user until now,
|
|
// or the user could be super user.
|
|
accessFlags=0L;
|
|
int idx = usrRunTime.sec.GetPlantSecurityIndex(curpath);
|
|
accessFlags = usrRunTime.sec.GetPlantSecurity(idx);
|
|
return true;
|
|
}
|
|
|
|
public override void DoListView(ListView veoListView)
|
|
{
|
|
ListViewItem item=null;
|
|
veoListView.Columns.Add("Location", 120, HorizontalAlignment.Left);
|
|
veoListView.Columns.Add("Title", 300, HorizontalAlignment.Left);
|
|
|
|
for (int i=0; i<Children.Count; i++)
|
|
{
|
|
VEO_ProcSet ps = (VEO_ProcSet) Children[i];
|
|
item = new ListViewItem(ps._Location,ps.icon);
|
|
item.Tag = ps;
|
|
item.SubItems.Add(ps._Title);
|
|
veoListView.Items.Add(item);
|
|
}
|
|
}
|
|
|
|
public override bool CollapseSibling()
|
|
{
|
|
if (!usrRunTime.InMultiUserMode) return false;
|
|
return true;
|
|
}
|
|
|
|
public override bool mnuAllowLckDB()
|
|
{
|
|
if (!usrRunTime.InMultiUserMode) return false;
|
|
//if (amILockedByMe()==true) return false;
|
|
if (Lock.LockStatus==VENetwork.Status.LockedByOther)return false;
|
|
// if there are no children, allow a lock in case the user is creating a plant level
|
|
// with procedure set
|
|
if (this.Children.Count==0) return true;
|
|
if ((accessFlags&Security.LOCKSET)==Security.LOCKSET && Lock.LockStatus==VENetwork.Status.NoLock) return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool mnuAllowUnlckDB()
|
|
{
|
|
if (!usrRunTime.InMultiUserMode) return false;
|
|
if ((accessFlags&Security.LOCKSET)==Security.LOCKSET&&(Lock.LockStatus==VENetwork.Status.Locked||
|
|
Lock.LockStatus==VENetwork.Status.LockPending)) return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool mnuAllowDelete()
|
|
{
|
|
if (amILockedByMe()==false) return false;
|
|
if(usrRunTime.sec.SystemAdminFlag) return true;
|
|
return false;
|
|
}
|
|
public override bool mnuAllowNew()
|
|
{
|
|
if (amILockedByMe()==false) return false;
|
|
if (usrRunTime.sec.PermissionToManageFlag) return true;
|
|
return false;
|
|
}
|
|
public override bool canEdit()
|
|
{
|
|
if (amILockedByMe()==false) return false;
|
|
if(usrRunTime.sec.SystemAdminFlag) return true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// the following class is used to support the New plant option from the 'Properties'
|
|
// dialog by making location to be editable.
|
|
class VEO_PlantN : VEO_Plant
|
|
{
|
|
public VEO_PlantN(UserRunTime iusrRunTime, string ititle, string ipath)
|
|
: base(iusrRunTime, ititle, ipath)
|
|
{
|
|
isNew=true;
|
|
}
|
|
|
|
// this method is used so that if a new datapath is created, it is associated
|
|
// with editable properties (such as path). When the object exists this is
|
|
// not editable. So when a new object is created, if it's successful, it's
|
|
// copied to an object which is not editable for the treeview & any further
|
|
// operations.
|
|
public override Object Copy()
|
|
{
|
|
VEO_Plant plnt = new VEO_Plant(usrRunTime,this._Title,this._Location);
|
|
plnt.parentObj = this.parentObj;
|
|
plnt.accessFlags = this.accessFlags;
|
|
return (Object) plnt;
|
|
}
|
|
|
|
public void SaveFields()
|
|
{
|
|
_Location=tmpLocation;
|
|
_Title=tmpTitle;
|
|
changeLocation=false;
|
|
changeTitle=false;
|
|
|
|
}
|
|
[Description("Location"),Category("Plant"),ReadOnly(false),EditorAttribute(typeof(VECreateFolderBrowserDlg), typeof(System.Drawing.Design.UITypeEditor))]public new string Location
|
|
{
|
|
get
|
|
{
|
|
if (!changeLocation)
|
|
return _Location;
|
|
else
|
|
return tmpLocation;
|
|
}
|
|
set
|
|
{
|
|
changeLocation=true;
|
|
tmpLocation=value;
|
|
}
|
|
}
|
|
}
|
|
}
|