1896 lines
65 KiB
C#
1896 lines
65 KiB
C#
/*********************************************************************************************
|
|
* Copyright 2021 - Volian Enterprises, Inc. All rights reserved.
|
|
* Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
|
|
* ------------------------------------------------------------------------------
|
|
* $Workfile: ctlXMLEdit.cs $ $Revision: 36 $
|
|
* $Author: Jsj $ $Date: 7/06/06 9:32a $
|
|
*
|
|
* $History: ctlXMLEdit.cs $
|
|
*
|
|
* ***************** Version 36 *****************
|
|
* User: Jsj Date: 7/06/06 Time: 9:32a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* needed full path to read ROAPP.INI
|
|
*
|
|
* ***************** Version 35 *****************
|
|
* User: Jsj Date: 5/03/05 Time: 11:44a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
*
|
|
* ***************** Version 34 *****************
|
|
* User: Jsj Date: 7/02/03 Time: 9:26a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* made messagebox calls modal by removing the parent window reference
|
|
*
|
|
* ***************** Version 33 *****************
|
|
* User: Kathy Date: 6/11/03 Time: 2:01p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* Bug fix B2003-045 (save date as part of graphic)
|
|
*
|
|
* ***************** Version 32 *****************
|
|
* User: Kathy Date: 5/21/03 Time: 12:41p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* B2003-036: save of group data to ro if both have a common field
|
|
*
|
|
* ***************** Version 31 *****************
|
|
* User: Kathy Date: 2/07/03 Time: 11:19a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* Error on pathname compares if long filename
|
|
*
|
|
* ***************** Version 30 *****************
|
|
* User: Kathy Date: 2/03/03 Time: 10:36a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* UI Improve
|
|
*
|
|
* ***************** Version 29 *****************
|
|
* User: Kathy Date: 1/22/03 Time: 12:17p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* duplicate/save as bug
|
|
*
|
|
* ***************** Version 28 *****************
|
|
* User: Kathy Date: 1/15/03 Time: 1:56p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* sizing of labels & form
|
|
*
|
|
* ***************** Version 27 *****************
|
|
* User: Kathy Date: 1/08/03 Time: 10:05a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* Add view image
|
|
*
|
|
* ***************** Version 26 *****************
|
|
* User: Jsj Date: 1/06/03 Time: 11:29a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* INI file logic
|
|
*
|
|
* ***************** Version 25 *****************
|
|
* User: Jsj Date: 1/02/03 Time: 3:47p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* Added logic to check INI files for default graphics file extension
|
|
*
|
|
* ***************** Version 24 *****************
|
|
* User: Jsj Date: 12/17/02 Time: 4:51p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* fixed date/time for graphic files
|
|
*
|
|
* ***************** Version 23 *****************
|
|
* User: Kathy Date: 12/16/02 Time: 12:11p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* once data is saved, don't flag it as changed
|
|
*
|
|
* ***************** Version 22 *****************
|
|
* User: Kathy Date: 12/13/02 Time: 10:05a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* bugs with combo (& more than one field with data)
|
|
*
|
|
* ***************** Version 21 *****************
|
|
* User: Jsj Date: 12/10/02 Time: 3:35p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* Default Graphic file extension fix
|
|
*
|
|
* ***************** Version 20 *****************
|
|
* User: Kathy Date: 12/10/02 Time: 2:24p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* fieldname special chars
|
|
*
|
|
* ***************** Version 19 *****************
|
|
* User: Kathy Date: 12/02/02 Time: 8:28a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* fieldname replace chars
|
|
*
|
|
* ***************** Version 18 *****************
|
|
* User: Kathy Date: 11/26/02 Time: 11:08a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* fix required bug on combo type & fix improve sizing
|
|
*
|
|
* ***************** Version 17 *****************
|
|
* User: Kathy Date: 11/20/02 Time: 11:36a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* zoom button moved on main form
|
|
*
|
|
* ***************** Version 16 *****************
|
|
* User: Kathy Date: 11/19/02 Time: 11:33a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* zoom tool tip & tab order
|
|
*
|
|
* ***************** Version 15 *****************
|
|
* User: Kathy Date: 10/24/02 Time: 11:15a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* some image file date (still needs fixed)
|
|
*
|
|
* ***************** Version 14 *****************
|
|
* User: Kathy Date: 10/15/02 Time: 2:14p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* required fields bug
|
|
*
|
|
* ***************** Version 13 *****************
|
|
* User: Kathy Date: 10/11/02 Time: 11:35a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* Required fields & restore data
|
|
*
|
|
* ***************** Version 12 *****************
|
|
* User: Kathy Date: 10/10/02 Time: 10:43a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* console.writeline->messagebox
|
|
*
|
|
* ***************** Version 11 *****************
|
|
* User: Kathy Date: 10/07/02 Time: 11:26a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* graphics image file support
|
|
*
|
|
* ***************** Version 10 *****************
|
|
* User: Kathy Date: 9/27/02 Time: 1:12p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* fix digit as first char in fieldname
|
|
*
|
|
* ***************** Version 9 *****************
|
|
* User: Jsj Date: 9/26/02 Time: 12:12p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* removed reference
|
|
*
|
|
* ***************** Version 8 *****************
|
|
* User: Jsj Date: 9/26/02 Time: 11:09a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* added reference to VLNXML
|
|
*
|
|
* ***************** Version 7 *****************
|
|
* User: Kathy Date: 9/25/02 Time: 9:54a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* remove xmlvln
|
|
*
|
|
* ***************** Version 6 *****************
|
|
* User: Kathy Date: 9/19/02 Time: 9:59a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* fix minor bugs
|
|
*
|
|
* ***************** Version 5 *****************
|
|
* User: Kathy Date: 9/11/02 Time: 1:13p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* vlnxml
|
|
*
|
|
* ***************** Version 4 *****************
|
|
* User: Kathy Date: 9/10/02 Time: 12:17p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* modify xpath expression to find field contents
|
|
*
|
|
* ***************** Version 3 *****************
|
|
* User: Kathy Date: 9/05/02 Time: 12:41p
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* dev
|
|
*
|
|
* ***************** Version 2 *****************
|
|
* User: Kathy Date: 8/30/02 Time: 9:42a
|
|
* Updated in $/LibSource/ctlXMLEditLib
|
|
* dev
|
|
*
|
|
* ***************** Version 1 *****************
|
|
* User: Jsj Date: 8/23/02 Time: 3:02p
|
|
* Created in $/LibSource/ctlXMLEditLib
|
|
*********************************************************************************************/
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Windows.Forms;
|
|
using System.Drawing.Imaging;
|
|
using System.Runtime.InteropServices;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.Text;
|
|
using RODBInterface;
|
|
using Org.Mentalis.Files;
|
|
//using IniFileIO;
|
|
|
|
|
|
|
|
namespace ctlXMLEditLib
|
|
{
|
|
/// <summary>
|
|
/// This windows control takes an input XML Schema and displays windows controls for the
|
|
/// schema elements.
|
|
/// If XML is also passed in, it uses that for the data.
|
|
/// Methods supported are:
|
|
/// ctlXMLEdit(VlnXmlElement myelem, XmlSchema myschema)
|
|
/// Constructor - VlnXmlElement contains data for edit and contains top
|
|
/// - document node if creating new xml data.
|
|
/// - XmlSchema contains field definitions
|
|
/// bool SaveData
|
|
/// - saves data in windows into passed in VlnXmlElement.
|
|
/// - returns true if successful, false if failed.
|
|
///
|
|
///
|
|
/// </summary>
|
|
public class ctlXMLEdit : System.Windows.Forms.UserControl
|
|
{
|
|
/// <summary>
|
|
/// Required designer variable.
|
|
/// </summary>
|
|
private System.ComponentModel.Container components = null;
|
|
private Random random = new Random();
|
|
private XmlSchema myXmlSchema;
|
|
private int screenx;
|
|
private int screeny;
|
|
private int tabindx;
|
|
public bool mysavexml;
|
|
private Hashtable myHT;
|
|
private bool dosaveflag;
|
|
private VlnXmlElement editelem;
|
|
private XmlDocument editdoc;
|
|
private TextBox zoomtextbox;
|
|
// the following is used for handling images. Note that if we want to have more
|
|
// than one image defined in an ro, this should be become a list.
|
|
private TextBox GraphicsFiletextbox;
|
|
private TextBox GraphicsWdtextbox;
|
|
private TextBox GraphicsHttextbox;
|
|
private System.Windows.Forms.Button btnFindFile;
|
|
private string GraphicsText;
|
|
private ToolTip zmtooltip;
|
|
private string DefaultGraphicFileExtension;
|
|
int MaxWidth; // largest textbox/groupbox width to size control.
|
|
int himage, wimage;
|
|
int hmin, hmax;
|
|
int wmin, wmax;
|
|
int MAXLT = 60; // make these defines
|
|
int MAXWT = 84;
|
|
int STDCPI = 12;
|
|
int STDLPI = 6;
|
|
int DPPL = (720/6);
|
|
int DPPC = (720/12);
|
|
int height, width;
|
|
|
|
/** C2021-026 the following are use for Parent Child RO fields **/
|
|
public ArrayList FieldsWithApplic = null;
|
|
public string[] PCChildren;
|
|
private GroupBox pcGrpBox = null;
|
|
/** end C2021-026 **/
|
|
|
|
// use this struct to define attributes for the text box fields, storing
|
|
// the pattern, radio button association, required field flag, etc.
|
|
struct TextBoxAttrTag
|
|
{
|
|
bool required; //whether the field is required
|
|
string req_msg; //message to print if required, but not set
|
|
string pattern; //pattern for validation
|
|
RadioButton radio; // if this text box has associated radio button
|
|
bool imagechild; //whether this field is a subchild of an image
|
|
string imagename; //if subchild of image, name of image parent (for save)
|
|
string imagedate; //if this was filename, save the date/time stamp
|
|
public TextBoxAttrTag(bool reqd, string ptn, RadioButton rd, bool img,
|
|
string imgname, string imgdate)
|
|
{
|
|
this.req_msg = null;
|
|
this.required = reqd;
|
|
this.pattern = ptn;
|
|
this.radio = rd;
|
|
this.imagechild = img;
|
|
this.imagename = imgname;
|
|
this.imagedate = imgdate;
|
|
}
|
|
public void SetPattern(string pattern) {this.pattern = pattern;}
|
|
public void SetRequired(bool req) {this.required = req;}
|
|
public void SetRequiredMessage(string ireq_msg) {this.req_msg = ireq_msg;}
|
|
public string GetPattern { get {return pattern;}}
|
|
public string GetRequiredMessage { get {return req_msg;}}
|
|
public bool GetRequired { get {return required;}}
|
|
public RadioButton GetRadio { get {return radio;}}
|
|
public bool GetImageChild { get {return imagechild;}}
|
|
public string GetImageName { get {return imagename;}}
|
|
public string GetImageDate { get {return imagedate;}}
|
|
public void SetImageDate(string imgdate) {this.imagedate = imgdate;}
|
|
}
|
|
|
|
public ctlXMLEdit(VlnXmlElement myelem, XmlSchema myschema, ArrayList reqfields, ArrayList fldsWithApplic, string [] pckids)
|
|
{
|
|
// This call is required by the Windows.Forms Form Designer.
|
|
InitializeComponent();
|
|
FieldsWithApplic = fldsWithApplic;
|
|
PCChildren = pckids; //C2021-026 list of Parent/Child children
|
|
zmtooltip = new ToolTip();
|
|
myHT = new Hashtable();
|
|
tabindx=0;
|
|
screenx=8;
|
|
screeny=10;
|
|
MaxWidth = 0;
|
|
mysavexml = false;
|
|
dosaveflag = false;
|
|
editelem = myelem;
|
|
editdoc = myelem.OwnerDocument;
|
|
myXmlSchema = myschema;
|
|
GraphicsText = null;
|
|
GraphicsFiletextbox = null;
|
|
// DefaultGraphicFileExtension = ".TIF"; // default graphics file extension
|
|
string ApplicationPath = Application.StartupPath;
|
|
string ROINI = Directory.GetCurrentDirectory()+ "\\ROAPP.INI";
|
|
|
|
// Get the default file extension for graphic files
|
|
// DefaultGraphicFileExtension = TheIniFile.GetINIKeyValueStr("ROApp","Extention","",5,"ROAPP.INI");
|
|
// Bug fix: B2006-025
|
|
// needed to pass the full path of ROAPP.INI
|
|
// B2025-007 only use the default file location (remove 16 bit PROMS location)
|
|
IniReader in1 = new IniReader(ROINI);
|
|
DefaultGraphicFileExtension = in1.ReadString("ROApp", "Extention");
|
|
if (string.IsNullOrEmpty(DefaultGraphicFileExtension)) DefaultGraphicFileExtension = in1.ReadString("ROApp", "Extension", ".TIF");
|
|
// if (File.Exists(PromsINI))
|
|
// DefaultGraphicFileExtension = TheIniFile.GetINIKeyValueStr("Graphics","defaultext",".TIF",5,PromsINI);
|
|
// if (File.Exists("ROAPP.INI"))
|
|
// DefaultGraphicFileExtension = TheIniFile.GetINIKeyValueStr("ROApp","Extention",".TIF",5,"ROAPP.INI");
|
|
if (!DefaultGraphicFileExtension.StartsWith("."))
|
|
DefaultGraphicFileExtension = "." + DefaultGraphicFileExtension;
|
|
|
|
// Put out window fields based on schema fields.
|
|
DisplaySchemaControls(myXmlSchema);
|
|
|
|
// Add field data to fields.
|
|
DisplayFieldContents((XmlNode) myelem);
|
|
|
|
// Set required fields based on list. (can add message later).
|
|
SetRequiredFields(reqfields);
|
|
dosaveflag=true;
|
|
}
|
|
|
|
// set the required fields tag on those fields which are included in the passed
|
|
// in required fields list.
|
|
private void DoSet(TextBox hwnd, string msg)
|
|
{
|
|
if (hwnd == null) return;
|
|
if (hwnd.Tag != null)
|
|
{
|
|
TextBoxAttrTag tag = (TextBoxAttrTag) hwnd.Tag;
|
|
tag.SetRequired(true);
|
|
tag.SetRequiredMessage(msg);
|
|
hwnd.Tag = tag;
|
|
}
|
|
}
|
|
|
|
private void SetRequiredFields(ArrayList reqfields)
|
|
{
|
|
Object o;
|
|
TextBox hwnd;
|
|
string field, msg;
|
|
int indx;
|
|
foreach (string strfld in reqfields)
|
|
{
|
|
indx = strfld.IndexOf("\t"); // message is stored after field, tab delim
|
|
field = strfld.Substring(0,indx);
|
|
msg = strfld.Substring(indx,strfld.Length-indx);
|
|
|
|
o = null;
|
|
o = myHT[field];
|
|
if (o == null)
|
|
{
|
|
// there may be an a,b,c,d tacked on to represent combo types.
|
|
// try them. if we have a combo type, then set them all as required
|
|
// because the checker will only check the one that is visible.
|
|
o = myHT[field+"a"];
|
|
if (o != null) // set all combo types required, the checker
|
|
{
|
|
DoSet((TextBox)o,msg);
|
|
DoSet((TextBox)myHT[field+"b"],msg);
|
|
DoSet((TextBox)myHT[field+"c"],msg);
|
|
DoSet((TextBox)myHT[field+"d"],msg);
|
|
}
|
|
}
|
|
else if (o != null)
|
|
{
|
|
hwnd = (TextBox) o;
|
|
if (hwnd.Tag != null)
|
|
{
|
|
TextBoxAttrTag tag = (TextBoxAttrTag) hwnd.Tag;
|
|
tag.SetRequired(true);
|
|
tag.SetRequiredMessage(msg);
|
|
hwnd.Tag = tag;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// C2021-026 If this is a Parent/Child field that has no value saved in the database
|
|
// then use the parent's value and display it as grey colored text.
|
|
private void GetDefaultParentValue(TextBox tb, XmlNode node, string chldName)
|
|
{
|
|
XmlNode parentNode = null;
|
|
// PCChildren contains a list strings reprenting the Children setup in the current Working Draft Parent/Child property
|
|
if (PCChildren == null) return; // C2021-026 no children to process
|
|
int pcChildIdx = 0; // C2021-026 corresponds with DocVersionConfig.SelectedSlave value: 0 = no child selected 1 = first child ...
|
|
foreach (string c in PCChildren)
|
|
{
|
|
pcChildIdx++;
|
|
string csufx = string.Format("_PCCHILD{0}", pcChildIdx); // C2021-026 create a child field name
|
|
if (chldName.EndsWith(csufx))
|
|
{
|
|
int idx = chldName.LastIndexOf(csufx);
|
|
if (idx > 0)
|
|
{
|
|
string parent = chldName.Remove(idx);
|
|
parentNode = node.SelectSingleNode(parent);
|
|
// if not found with just the string, search the tree.
|
|
if (parentNode == null) parentNode = node.SelectSingleNode("*/" + parent);
|
|
if (parentNode != null)
|
|
{
|
|
bool orgMySaveXML = mysavexml;
|
|
tb.Text = parentNode.InnerText; // set the P/C Child text box to the parent's value
|
|
tb.ForeColor = SystemColors.GrayText;
|
|
// B2021-077 Setting tb.Text triggers the need to save.
|
|
// In this case it's for visual purposes only, so no need to trigger the save
|
|
// but if mysavexml is already turn, then don't set it to false
|
|
if (!orgMySaveXML)
|
|
{
|
|
mysavexml = false;
|
|
dosaveflag = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Given a parent XmlNode, walk through the child nodes & add the text for the
|
|
// node to the associated text box.
|
|
private void DisplayFieldContents(XmlNode node)
|
|
{
|
|
Object o;
|
|
TextBox hwnd;
|
|
XmlNode nd;
|
|
// if we have an image, check it for validity, i.e. file exists, etc.??
|
|
foreach (string str in myHT.Keys)
|
|
{
|
|
o = myHT[str];
|
|
hwnd = (TextBox) o;
|
|
nd = node.SelectSingleNode(str);
|
|
// if not found with just the string, search the tree.
|
|
if (nd==null)nd = node.SelectSingleNode("*/"+str);
|
|
if (nd == null || nd.InnerText.Length==0) // B2024-004 use Parent value if Child text length is zero
|
|
GetDefaultParentValue(hwnd, node, str); // C2021-026 Parent/Child Field has no value so use parent's value
|
|
else
|
|
{
|
|
hwnd.Text = nd.InnerText; // set the field's text from XML
|
|
|
|
// check if this window has a button name as part of its tag. If
|
|
// so it's a combo type & the radio button/visibility may need to
|
|
// be reset. If this button is not checked (during setup), then
|
|
// check it. By setting it's Checked property to true, an event
|
|
// is thrown which causes the code to be run which turns off/on
|
|
// visibility of the text boxes.
|
|
if (hwnd.Tag != null)
|
|
{
|
|
TextBoxAttrTag tag = (TextBoxAttrTag) hwnd.Tag;
|
|
RadioButton radio;
|
|
radio = tag.GetRadio;
|
|
|
|
if (radio != null )
|
|
{
|
|
// Use a tag on the groupbox to know that the radio button
|
|
// was set - the first xml element in the group is the
|
|
// active one.
|
|
GroupBox gp = (GroupBox) radio.Parent;
|
|
if (gp.Tag == null && radio.Checked == false)
|
|
{
|
|
// see if this is the first member of the group in the
|
|
// xml node.
|
|
string nmgr = str.Substring(0,str.Length-1);
|
|
XmlNode grpnd = (XmlNode) editelem.FirstChild;
|
|
bool first = true;
|
|
while (grpnd != null)
|
|
{
|
|
if (grpnd.Name.Substring(0,grpnd.Name.Length-1) == nmgr)
|
|
{
|
|
if (grpnd.Name == str)
|
|
{
|
|
if (first)
|
|
{
|
|
radio.Checked = true;
|
|
radio.Parent.Tag = true;
|
|
}
|
|
break;
|
|
}
|
|
first = false;
|
|
}
|
|
grpnd = grpnd.NextSibling;
|
|
}
|
|
}
|
|
}
|
|
bool img;
|
|
img = tag.GetImageChild;
|
|
if (img==true && str == "Image_Filename")
|
|
{
|
|
int indx = hwnd.Text.IndexOf(" ");
|
|
if (indx>=0)
|
|
{
|
|
tag.SetImageDate(hwnd.Text.Substring(0,indx));
|
|
hwnd.Tag = tag;
|
|
hwnd.Text = hwnd.Text.Substring(indx+1,hwnd.Text.Length-indx-1);
|
|
}
|
|
}
|
|
if (img==true && str == "Image_Width")
|
|
width = System.Convert.ToInt32(hwnd.Text);
|
|
if (img==true && str == "Image_Height")
|
|
height = System.Convert.ToInt32(hwnd.Text);
|
|
}
|
|
}
|
|
}
|
|
// if we're doing an image file & all data has been set, update the
|
|
// height/width data of the image.
|
|
if (GraphicsFiletextbox != null && GraphicsFiletextbox.Text != "") UpdateHtWd();
|
|
}
|
|
public TextBox GetGraphicsFiletextbox()
|
|
{
|
|
return GraphicsFiletextbox;
|
|
}
|
|
public int GetMaxWidth()
|
|
{
|
|
// if MaxWidth is small, a scroll bar appears below the fields
|
|
// so make this a bit larger, so a scroll bar doesn't appear
|
|
if (MaxWidth < 30) return MaxWidth + 100;
|
|
return MaxWidth + 70;
|
|
}
|
|
public int GetMaxLength()
|
|
{
|
|
return screeny+50;
|
|
}
|
|
public void SetNotSaved()
|
|
{
|
|
mysavexml = true;
|
|
}
|
|
/// <summary>
|
|
/// Clean up any resources being used.
|
|
/// </summary>
|
|
protected override void Dispose( bool disposing )
|
|
{
|
|
zmtooltip.RemoveAll();
|
|
if( disposing )
|
|
{
|
|
if( components != null )
|
|
components.Dispose();
|
|
}
|
|
base.Dispose( disposing );
|
|
}
|
|
|
|
// RestoreData restores the data in the text boxes to be that which was originally
|
|
// sent into the control (ctlXMLEdit)
|
|
public void RestoreData()
|
|
{
|
|
dosaveflag=false;
|
|
mysavexml=false;
|
|
TextBox hwnd;
|
|
// first, clear out all of the text boxes.
|
|
|
|
foreach (string str in myHT.Keys)
|
|
{
|
|
object o = myHT[str];
|
|
hwnd = (TextBox) o;
|
|
hwnd.Text = "";
|
|
TextBoxAttrTag tag = (TextBoxAttrTag) hwnd.Tag;
|
|
RadioButton radio;
|
|
radio = tag.GetRadio;
|
|
if (radio != null )
|
|
{
|
|
GroupBox gp = (GroupBox) radio.Parent;
|
|
gp.Tag = null;
|
|
}
|
|
}
|
|
// Add field data to fields.
|
|
DisplayFieldContents((XmlNode) editelem);
|
|
dosaveflag=true;
|
|
}
|
|
|
|
public bool DataChanged()
|
|
{
|
|
if (mysavexml) return true;
|
|
return false;
|
|
}
|
|
|
|
//B2015-089 - restore the inner xml data when user duplicated an RO and tried to save with out giving it a new setpoint ID (Accessory Page ID)
|
|
public void RestoreInnerXml(string savedInnerXml)
|
|
{
|
|
editelem.InnerXml = savedInnerXml;
|
|
}
|
|
|
|
//C2021-026 when saving the RO record, if a PC Child's textbox contains a value identical
|
|
// to the parent's value, then clear the child's textbox so that nothing is saved
|
|
// to the database. This allow us to know that a specific value was not set
|
|
// for this Parent/Child child
|
|
private void RemovePCChildTextIfSameAsParent(XmlNode node, TextBox tb, string chldName)
|
|
{
|
|
XmlNode parentNode = null;
|
|
// if this is a child node get the parent's value
|
|
// PCChildren contains a list strings reprenting the Children setup in the current Working Draft Parent/Child property
|
|
if (PCChildren == null) return;
|
|
int pcChildIdx = 0;
|
|
foreach (string c in PCChildren)
|
|
{
|
|
//string csufx = CvtUserFldToFld(c);
|
|
pcChildIdx++;
|
|
string csufx = string.Format("_PCCHILD{0}", pcChildIdx);
|
|
if (chldName.EndsWith(csufx))
|
|
{
|
|
int idx = chldName.LastIndexOf(csufx);
|
|
if (idx > 0)
|
|
{
|
|
string parent = chldName.Remove(idx);
|
|
parentNode = node.SelectSingleNode(parent);
|
|
// if not found with just the string, search the tree.
|
|
if (parentNode == null) parentNode = node.SelectSingleNode("*/" + parent);
|
|
// C2021-026 if the text is grey it's a child field using the parent's value
|
|
// we need to clear the child's text box so that it will reset using the new parent's value
|
|
if (parentNode != null && (parentNode.InnerText == tb.Text || tb.ForeColor == SystemColors.GrayText))
|
|
{
|
|
tb.Text = "";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// SaveData saves the data in the element which had been sent to the control. Return
|
|
// true if success, false if fail.
|
|
// Note that the Parent and Child XML node variables below are not coding for Parent/Child Applicabily Fields
|
|
public bool SaveData()
|
|
{
|
|
if (mysavexml)
|
|
{
|
|
TextBox hwnd;
|
|
TextBoxAttrTag tag;
|
|
string imgdate;
|
|
|
|
//go thru the hash table to get textboxes. Find the ones that have text.
|
|
foreach (string str in myHT.Keys)
|
|
{
|
|
object o = myHT[str];
|
|
hwnd = (TextBox) o;
|
|
imgdate = null;
|
|
// if this is a required field and there is no text, put out an error
|
|
// message and get out of here.
|
|
if (hwnd.Tag != null)
|
|
{
|
|
tag = (TextBoxAttrTag) hwnd.Tag;
|
|
if (tag.GetRequired == true && hwnd.Visible == true && (hwnd.Text == null || hwnd.Text == ""))
|
|
{
|
|
string message = CvtFldToUserFld(str) + " must be entered because it is\nused to define the " + tag.GetRequiredMessage;
|
|
string caption = "Error on Save RO Data";
|
|
MessageBoxButtons buttons = MessageBoxButtons.OK;
|
|
DialogResult result;
|
|
result = MessageBox.Show(message, caption, buttons);
|
|
return (false);
|
|
}
|
|
imgdate = tag.GetImageDate;
|
|
}
|
|
|
|
// find the element in the current element node.
|
|
// if text exists and the element exists, just reset the innertext.
|
|
// if text exists and it's a new element, add it.
|
|
// if the element is there and there's no text. delete it.
|
|
XmlNode elmnode = (XmlNode) editelem;
|
|
XmlNode nd = elmnode.SelectSingleNode(str);
|
|
if (nd == null) nd = elmnode.SelectSingleNode("*/"+str);
|
|
RemovePCChildTextIfSameAsParent(elmnode, hwnd, str); // C2021-026 will clear hwnd.Text if child value is same as parent value
|
|
// handle, element exists - but text removed first (delete element)
|
|
if ((hwnd.Text == null || hwnd.Text == "") && nd != null)
|
|
{
|
|
XmlNode parent = nd.ParentNode;
|
|
parent.RemoveChild(nd);
|
|
}
|
|
else
|
|
{
|
|
// found the node, just set text and text exists, just modify text.
|
|
if (nd != null)
|
|
{
|
|
if (str == "Image_Filename")
|
|
nd.InnerText = imgdate + " " + hwnd.Text;
|
|
else
|
|
nd.InnerText = hwnd.Text;
|
|
}
|
|
// node not here. Make a new element
|
|
else if (hwnd.Text != null && hwnd.Text != "")
|
|
{
|
|
// if this is part of an image, then be sure that the
|
|
// parent image node was created and if not, create it.
|
|
bool ischldimag = false;
|
|
if (hwnd.Tag != null)
|
|
{
|
|
tag = (TextBoxAttrTag) hwnd.Tag;
|
|
if (tag.GetImageChild == true) ischldimag = true;
|
|
}
|
|
if (ischldimag)
|
|
{
|
|
tag = (TextBoxAttrTag) hwnd.Tag; // yikes, compile errors
|
|
string imagnm = tag.GetImageName;
|
|
VlnXmlElement ielm;
|
|
VlnXmlElement newelem;
|
|
nd = elmnode.SelectSingleNode(imagnm);
|
|
if (nd == null) // make this image node.
|
|
{
|
|
newelem = (VlnXmlElement) editdoc.CreateElement(imagnm);
|
|
editelem.AppendChild((XmlNode) newelem);
|
|
ielm = newelem;
|
|
}
|
|
else
|
|
ielm = (VlnXmlElement) nd;
|
|
newelem = (VlnXmlElement) editdoc.CreateElement(str);
|
|
if (str == "Image_Filename")
|
|
newelem.InnerText = imgdate + " " + hwnd.Text;
|
|
else
|
|
newelem.InnerText = hwnd.Text;
|
|
ielm.AppendChild((XmlNode) newelem);
|
|
}
|
|
else
|
|
{
|
|
// just added at the current level
|
|
VlnXmlElement newelem = (VlnXmlElement) editdoc.CreateElement(str);
|
|
newelem.InnerText = hwnd.Text;
|
|
editelem.AppendChild((XmlNode) newelem);
|
|
nd = (XmlNode) newelem;
|
|
}
|
|
}
|
|
// check on order of combo types if this was one. Note that the 'active'
|
|
// type within the combo, i.e. text, variable, table or xyplot, must
|
|
// be the first one in xml tree (before the others) in order to be the
|
|
// active one as presented to user. This was done since more than one can have data.
|
|
if (hwnd.Tag != null)
|
|
{
|
|
tag = (TextBoxAttrTag) hwnd.Tag;
|
|
RadioButton rb = tag.GetRadio;
|
|
if (rb != null)
|
|
{
|
|
if (rb.Checked == true)
|
|
{
|
|
// this one needs to be before any others (of the same
|
|
// group type) in the xml childlist - just make it 1st.
|
|
XmlNode parent = nd.ParentNode;
|
|
parent.RemoveChild(nd);
|
|
parent.PrependChild(nd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DisplayFieldContents((XmlNode) editelem); // to refresh display after saving Parent/Child fields to show default values
|
|
// B2021-077 we saved the information. set the need to save flags to false
|
|
mysavexml = false; // data has been saved, don't allow it again.
|
|
dosaveflag = false;
|
|
return (true);
|
|
}
|
|
MessageBox.Show("Save Failed");
|
|
return (false);
|
|
}
|
|
|
|
#region Component Designer generated code
|
|
/// <summary>
|
|
/// Required method for Designer support - do not modify
|
|
/// the contents of this method with the code editor.
|
|
/// </summary>
|
|
private void InitializeComponent()
|
|
{
|
|
this.btnFindFile = new System.Windows.Forms.Button();
|
|
this.SuspendLayout();
|
|
//
|
|
// btnFindFile
|
|
//
|
|
this.btnFindFile.Location = new System.Drawing.Point(608, 8);
|
|
this.btnFindFile.Name = "btnFindFile";
|
|
this.btnFindFile.Size = new System.Drawing.Size(96, 24);
|
|
this.btnFindFile.TabIndex = 1;
|
|
this.btnFindFile.Text = "Find File";
|
|
this.btnFindFile.Visible = false;
|
|
this.btnFindFile.Click += new System.EventHandler(this.btnFindFile_click);
|
|
this.ResumeLayout(false);
|
|
|
|
this.Controls.Add(btnFindFile);
|
|
|
|
}
|
|
#endregion
|
|
|
|
// Given a schema, display labels or radio buttons and their associated textboxes
|
|
// Radio button names are derived from removing the type from the element name.
|
|
private void DisplaySchemaControls(XmlSchema myXmlSchema)
|
|
{
|
|
// the first element is the group name, get past this to the data. This group
|
|
// name is a complex type, which is processed below.
|
|
bool first=true;
|
|
try
|
|
{
|
|
foreach(object item in myXmlSchema.Items)
|
|
{
|
|
if (item is XmlSchemaElement && first)
|
|
{
|
|
first=false;
|
|
}
|
|
|
|
// in the RO schema (and any types derived from it), the fields are
|
|
// defined within the ComplexType.
|
|
if (item is XmlSchemaComplexType)
|
|
DisplayXmlSchemaComplexType((XmlSchemaComplexType)item); //complexType
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
MessageBox.Show(e.ToString(),"Error displaying fields from schema");
|
|
}
|
|
}
|
|
|
|
|
|
//XmlSchemaComplexType
|
|
private void DisplayXmlSchemaComplexType(XmlSchemaComplexType complexType)
|
|
{
|
|
if (complexType.ContentModel == null)
|
|
{
|
|
if (complexType.Particle != null)
|
|
DisplayXmlSchemaParticle(complexType.Particle);
|
|
}
|
|
}
|
|
|
|
//XmlSchemaSimpleType processes a simple type schema element which contains a fields
|
|
// attributes such as patterns, maxLength and whether it is single (type is
|
|
// 'normalizedString') or a multiline text box(type is 'string'). Also, a radio
|
|
// button is passed in if this was called to handle an element within a combo type.
|
|
// This button is saved for a given text box so that initialization of these combo types can occur.
|
|
private string DisplayXmlSchemaSimpleType(XmlSchemaSimpleType simpleType, TextBox mytextbox, RadioButton radio,
|
|
bool img, string imgname)
|
|
{
|
|
// set up for text box tag, which stores whether field is required and
|
|
// if a pattern exists for validation.
|
|
string pattern = null;
|
|
string getannot=null;
|
|
if (simpleType.Annotation != null)
|
|
{
|
|
object item = simpleType.Annotation.Items[0];
|
|
if (item is XmlSchemaDocumentation)
|
|
{
|
|
XmlSchemaDocumentation doc = (XmlSchemaDocumentation) item;
|
|
XmlNode[] node = (XmlNode[]) doc.Markup;
|
|
// Note: this has nothing to do with PROMS Annotations. This is more of a field type description
|
|
// used for Graphics (figures) RO fields to setup event handlers and buttons to display a Find File Dialog
|
|
getannot = node[0].InnerText;
|
|
if (getannot == "VLN_FINDFILE")
|
|
{
|
|
this.btnFindFile.Location = new System.Drawing.Point(mytextbox.Location.X+mytextbox.Width+50,mytextbox.Location.Y-(2*(int)mytextbox.Font.GetHeight()));
|
|
this.btnFindFile.Visible = true;
|
|
GraphicsFiletextbox = mytextbox;
|
|
GraphicsFiletextbox.LostFocus += new System.EventHandler(this.GraphicText_lostfocus);
|
|
getannot = null;
|
|
}
|
|
if (getannot!=null && getannot!="")
|
|
{
|
|
if (getannot.IndexOf("Lines")>=0)
|
|
{
|
|
GraphicsHttextbox = mytextbox;
|
|
mytextbox.LostFocus += new System.EventHandler(this.GraphicsHt_lostfocus);
|
|
}
|
|
if (getannot.IndexOf("Character")>=0)
|
|
{
|
|
GraphicsWdtextbox = mytextbox;
|
|
mytextbox.LostFocus += new System.EventHandler(this.GraphicsWd_lostfocus);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (simpleType.Content is XmlSchemaSimpleTypeRestriction)
|
|
{
|
|
// A Schema Type Restriction is used to define single or multi-line boxes.
|
|
XmlSchemaSimpleTypeRestriction myRestrictions = (XmlSchemaSimpleTypeRestriction) simpleType.Content;
|
|
if (myRestrictions.BaseTypeName.Name == "normalizedString")
|
|
mytextbox.Multiline = false;
|
|
else
|
|
{
|
|
mytextbox.Multiline = true;
|
|
mytextbox.AcceptsReturn = true;
|
|
mytextbox.Height = (int) mytextbox.Font.GetHeight() * 4;
|
|
mytextbox.ScrollBars = ScrollBars.Vertical;
|
|
zmtooltip.SetToolTip(mytextbox, "Press Shift F2 To Zoom");
|
|
}
|
|
|
|
// Schema facets were used for maxlength & patterns, process these if found.
|
|
foreach(XmlSchemaFacet facet in myRestrictions.Facets)
|
|
{
|
|
if (facet is XmlSchemaMaxLengthFacet)
|
|
{
|
|
if (mytextbox.Multiline == false)
|
|
mytextbox.MaxLength = System.Convert.ToInt32(facet.Value);
|
|
// if the box is small, make the width a little bigger so maxlength text can fit.
|
|
int wd = System.Convert.ToInt32(facet.Value);
|
|
if (wd<5) wd++;
|
|
mytextbox.Width = (int) mytextbox.Font.SizeInPoints * wd;
|
|
MaxWidth = (mytextbox.Width>MaxWidth)?mytextbox.Width:MaxWidth;
|
|
}
|
|
else if (facet is XmlSchemaPatternFacet)
|
|
{
|
|
pattern = facet.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now setup a tag for the text box which will store attributes associated with it
|
|
// for seeing if it is a required field, checking a pattern or processing a radio box
|
|
// initialization.
|
|
if (mytextbox.Tag == null)
|
|
{
|
|
TextBoxAttrTag tag = new TextBoxAttrTag(false, pattern, radio, img, (img?imgname:null), null);
|
|
mytextbox.Tag = (object) tag;
|
|
}
|
|
return getannot;
|
|
}
|
|
|
|
//XmlSchemaParticle's contain the individual schema elements which represent
|
|
// fields defined for this given RO group. It may also contain a schema 'choice'
|
|
// which was used to handle the combo type data type fields.
|
|
private void DisplayXmlSchemaParticle(XmlSchemaParticle particle)
|
|
{
|
|
if (particle is XmlSchemaElement)
|
|
DisplayXmlSchemaElement((XmlSchemaElement)particle);
|
|
else if (particle is XmlSchemaSequence)
|
|
{
|
|
foreach(XmlSchemaParticle particle1 in ((XmlSchemaSequence)particle).Items)
|
|
DisplayXmlSchemaParticle(particle1);
|
|
}
|
|
else if (particle is XmlSchemaChoice)
|
|
DisplayXmlSchemaChoice((XmlSchemaChoice) particle);
|
|
else
|
|
MessageBox.Show(particle.ToString(),"Not Implemented for this type");
|
|
}
|
|
|
|
// For a combo field, display the radio button & the text field. Select the first
|
|
// button. If data is also sent in during initialization of this control, i.e.
|
|
// edit versus new, the selected button will be changed during the XML file
|
|
// data load process.
|
|
// Return value (set as reference params): 'x' & 'y' size of the text field so that
|
|
// the caller can determine the max to set the group box x, y size value and know
|
|
// how far to move down on the screen.
|
|
private void DisplayXmlSchemaRadioAndTextBox(XmlSchemaElement element, GroupBox gbox, bool first, int x, int y,
|
|
int boxx, ref int retx, ref int rety)
|
|
{
|
|
int ysize;
|
|
RadioButton radio = new RadioButton();
|
|
radio.Location = new System.Drawing.Point(x,20);
|
|
radio.Name = element.Name + element.SchemaTypeName.Name;
|
|
string tmp;
|
|
if (element.SchemaTypeName.Name.Length>1 && char.IsDigit(element.SchemaTypeName.Name,1))
|
|
tmp = element.SchemaTypeName.Name.Substring(1,element.SchemaTypeName.Name.Length-1);
|
|
else
|
|
tmp = element.SchemaTypeName.Name;
|
|
radio.Text = CvtFldToUserFld(tmp);
|
|
|
|
radio.TabIndex = 0;
|
|
ysize = (int) radio.Height;
|
|
|
|
if (first) radio.Checked = true;
|
|
radio.CheckedChanged += new System.EventHandler(this.radiocheckchg);
|
|
gbox.Controls.Add(radio);
|
|
|
|
TextBox tb = new TextBox();
|
|
tb.Location = new Point(boxx+20, y+25);
|
|
if (!first) tb.Visible = false;
|
|
myHT.Add(element.Name,tb);
|
|
// add the textbox to the ctlxmledit control rather than groupbox - the
|
|
// groupbox is just to control the choices, the text box won't display if in
|
|
// the groupbox.
|
|
Controls.Add(tb);
|
|
tb.TextChanged += new System.EventHandler(this.textbox_change);
|
|
tb.GotFocus += new System.EventHandler(this.textbox_zoombtn);
|
|
tb.KeyDown += new KeyEventHandler(MyOnKeyDown);
|
|
gbox.Contains(tb);
|
|
// the following will set attributes on the text boxes such as maxlength, multiline, etc.
|
|
DisplayXmlSchemaSimpleType((XmlSchemaSimpleType)element.SchemaType, tb, radio,false,null);
|
|
int chldGrpHeight = 0;
|
|
if (FieldsWithApplic != null && FieldsWithApplic.Contains(gbox.Text) && radio.Text == "Fixed") // C2021-026 user turned appicability on for this field
|
|
{
|
|
int saveScreeny = screeny;
|
|
int saveScreenx = screenx;
|
|
screeny += tb.Height + 50;
|
|
screenx += 20;
|
|
pcGrpBox = null; // C2021-026 used to hide/show Parent/Child group when radio buttons are selected
|
|
DisplayAppicChildrenGroup(element, PCChildren, ref chldGrpHeight, gbox.Text); // C2021-026 make sub-group for Parent/Child child fields (if needed)
|
|
screeny = saveScreeny;
|
|
screenx = saveScreenx;
|
|
}
|
|
rety = (ysize + 25 + chldGrpHeight + tb.Height);
|
|
retx = tb.Width;
|
|
}
|
|
|
|
//XmlSchemaChoice: processes the 'combo data type' which is represented by a
|
|
// a schema choice element. This is handled by a group box and using radio
|
|
// button/textbox pairs to represent each element within the choice.
|
|
private void DisplayXmlSchemaChoice(XmlSchemaChoice choice)
|
|
{
|
|
bool first = true;
|
|
int screenposx, screenposy;
|
|
int maxyfortext=0,maxxfortext=0;
|
|
GroupBox groupbox = new GroupBox();
|
|
groupbox.SuspendLayout();
|
|
groupbox.Location = new System.Drawing.Point(screenx,screeny);
|
|
XmlSchemaElement elem = (XmlSchemaElement) choice.Items[0];
|
|
groupbox.Name = elem.Name;
|
|
groupbox.TabStop = false;
|
|
|
|
// remove the last character of the name for the title of the group box.
|
|
string tstr = CvtFldToUserFld(elem.Name);
|
|
groupbox.Text = tstr.Remove((tstr.Length)-1,1);
|
|
screenposx = screenx+20;
|
|
screenposy = screeny+20;
|
|
|
|
foreach (object o in choice.Items)
|
|
{
|
|
// put out a radio button/text box for each item in the choice.
|
|
int xmax=0, ymax=0;
|
|
DisplayXmlSchemaRadioAndTextBox((XmlSchemaElement) o,groupbox,first,screenposx,screenposy,screenx,ref xmax,ref ymax);
|
|
first = false;
|
|
maxyfortext = ymax>maxyfortext?ymax:maxyfortext;
|
|
maxxfortext = xmax>maxxfortext?xmax:maxxfortext;
|
|
screenposx = screenposx + 160;
|
|
}
|
|
|
|
// get the widths of all children of this group box & use this to set the size
|
|
// of the groupbox.
|
|
int gritms = groupbox.Controls.Count;
|
|
screeny = screeny + maxyfortext + 20;
|
|
MaxWidth = (maxxfortext+40>MaxWidth)?maxxfortext+40:MaxWidth;
|
|
groupbox.Size = new System.Drawing.Size(maxxfortext+40, maxyfortext+10);
|
|
Controls.Add(groupbox);
|
|
}
|
|
|
|
private void DisplayXmlSchemaElement(XmlSchemaElement element)
|
|
{
|
|
string userfldName = CvtFldToUserFld(element.Name);
|
|
string childLabel = "";
|
|
bool pcApplic = FieldsWithApplic != null && FieldsWithApplic.Contains(userfldName); // C2021-026 returns True if field should show Parent/Child Applicability fields
|
|
if (pcApplic) childLabel = CvtFldToUserFld(element.Name);
|
|
int dmy = 0;
|
|
DoDisplayXmlSchemaElement(element, childLabel, 0, ref dmy, Color.Transparent, 0);
|
|
if (pcApplic)
|
|
{
|
|
// C2021-026 this will create a grouping containing Parent/Child Applicability fields
|
|
DisplayAppicChildrenGroup(element, PCChildren, ref dmy, null);
|
|
screeny += 10;
|
|
}
|
|
}
|
|
// C2021-026 Creates a group box containing Parent/Child Applicability fields
|
|
// the group box is indented and shaded a blue color
|
|
private void DisplayAppicChildrenGroup(XmlSchemaElement element, string [] PCChildren, ref int chldgrphgt, string altGrpName)
|
|
{
|
|
int screenposx, screenposy;
|
|
int savescreenX = screenx;
|
|
screenx += 20;
|
|
GroupBox groupbox = new GroupBox();
|
|
groupbox.BackColor = Color.AliceBlue;
|
|
groupbox.SuspendLayout();
|
|
groupbox.Location = new System.Drawing.Point(screenx, screeny);
|
|
groupbox.Name = "PCgb_" + element.Name;
|
|
groupbox.TabStop = false;
|
|
|
|
// remove the last character of the name for the title of the group box.
|
|
string tstr = (altGrpName == null)?CvtFldToUserFld(element.Name):altGrpName;//(elem.Name);
|
|
groupbox.Text = "Child Values";
|
|
screenposx = screenx + 20;
|
|
screenposy = screeny + 20;
|
|
int screenySave = screeny;
|
|
screeny += 20;
|
|
int maxChldWidth = 0;
|
|
int pcChildIdx = 0;
|
|
foreach (string s in PCChildren)
|
|
{
|
|
string childLabel = s;
|
|
pcChildIdx++;
|
|
DoDisplayXmlSchemaElement(element, childLabel, 20, ref maxChldWidth,Color.AliceBlue, pcChildIdx);
|
|
}
|
|
// get the widths and number of all children of this group box & use this to set the size
|
|
// of the groupbox.
|
|
groupbox.Size = new System.Drawing.Size(Math.Max(105,maxChldWidth + 40), screeny - screenySave + 5); // B2021-079 increased the minimum width
|
|
chldgrphgt = screeny - screenySave + 5;
|
|
Controls.Add(groupbox);
|
|
if (pcGrpBox == null)
|
|
pcGrpBox = groupbox; // only save if is in a Choice (radio button) group - used to hide/unhide the P/C Group box when radio buttons are selected
|
|
screenx = savescreenX;
|
|
}
|
|
private void DoDisplayXmlSchemaElement(XmlSchemaElement element, string applicLabel, int indent, ref int maxwidth, Color chlbckcolor, int pcChildIdx)
|
|
{
|
|
// always add a label.
|
|
int sscreeny;
|
|
string userfldName = CvtFldToUserFld(element.Name);
|
|
string pcChildFldName = element.Name; // C2021-026 PC Child field name
|
|
// C2021-026 the first PC Child has pcChildIdx of one
|
|
if (pcChildIdx > 0)
|
|
pcChildFldName += string.Format("_PCCHILD{0}", pcChildIdx);
|
|
Label mylabel;
|
|
mylabel = new System.Windows.Forms.Label();
|
|
mylabel.BackColor = chlbckcolor; // PC Applic fields are shaded blue otherwise backcolor is transparent
|
|
mylabel.Location = new Point(screenx+indent, screeny);
|
|
mylabel.Name = (pcChildIdx == 0) ? CvtUserFldToFld(element.Name) : CvtUserFldToFld(pcChildFldName);
|
|
mylabel.Text = (applicLabel.Length > 0) ? applicLabel : CvtFldToUserFld(element.Name).Replace("Image_",""); // C2021-026 applicLabel is the P/C Child name
|
|
mylabel.AutoSize = true;
|
|
Controls.Add(mylabel);
|
|
// add 3 onto screeny so that textbox is slightly below label.
|
|
screeny = screeny + mylabel.Height + 3;
|
|
sscreeny = screeny; // save 'y' location in case of annotation.
|
|
if (element.SchemaType != null && element.SchemaType is XmlSchemaComplexType)
|
|
{
|
|
GraphicsText = element.Name;
|
|
DisplayXmlSchemaComplexType((XmlSchemaComplexType)element.SchemaType);
|
|
screeny+=30;
|
|
}
|
|
else
|
|
{
|
|
TextBox mytextbox;
|
|
mytextbox = new TextBox();
|
|
mytextbox.Location = new Point(screenx+indent, screeny);
|
|
string tFieldName = (pcChildIdx == 0) ? CvtUserFldToFld(element.Name) : CvtUserFldToFld(pcChildFldName);
|
|
myHT.Add(tFieldName, mytextbox);
|
|
tabindx++;
|
|
Controls.Add(mytextbox);
|
|
screeny = screeny + 10;
|
|
mytextbox.TextChanged += new System.EventHandler(this.textbox_change);
|
|
mytextbox.Validating += new System.ComponentModel.CancelEventHandler(this.textbox_Validating);
|
|
mytextbox.GotFocus += new System.EventHandler(this.textbox_zoombtn);
|
|
mytextbox.KeyDown += new KeyEventHandler(MyOnKeyDown);
|
|
if (pcChildIdx > 0)
|
|
{
|
|
mytextbox.Enter += new System.EventHandler(this.txtBox_Enter);
|
|
mytextbox.Leave += new System.EventHandler(this.txtBox_Leave);
|
|
}
|
|
|
|
string labelAnnot;
|
|
bool imgchld = false;
|
|
if (element.Name == "Image_Filename" || element.Name == "Image_Height" || element.Name == "Image_Width") imgchld = true;
|
|
// Pass the textbox in to set attributes such as maxlength, multiline and pattern
|
|
// DisplayXmlSchemaSimpleType will set up
|
|
// - the textbox length which is needed to determin the Parent/Child group box width
|
|
// - add special buttons and events for Graphic (figure) RO type fields
|
|
labelAnnot = DisplayXmlSchemaSimpleType((XmlSchemaSimpleType)element.SchemaType,mytextbox, null,imgchld,GraphicsText);
|
|
if (labelAnnot != null)
|
|
{
|
|
// this is part of a Graphics (figure) RO - either the height or width adjustment text box
|
|
// so put a lable next to the respective height/width text box
|
|
Label annot;
|
|
annot = new System.Windows.Forms.Label();
|
|
annot.Location = new Point(screenx+mytextbox.Width+10, sscreeny);
|
|
annot.Name = "annot" + screeny.ToString();
|
|
annot.Text = labelAnnot;
|
|
annot.AutoSize = true;
|
|
Controls.Add(annot);
|
|
}
|
|
screeny += mytextbox.Height;
|
|
maxwidth = Math.Max(maxwidth, mylabel.Width); // is the label wider?
|
|
maxwidth = Math.Max(mytextbox.Width, maxwidth); // is the text box wider?
|
|
}
|
|
}
|
|
|
|
// the following is needed to load the control.
|
|
private void ctlXMLEdit_Load(object sender, System.EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
// when data in a text box has changed, flag it (except for when this
|
|
// happens during loading of original data). This flag will be used
|
|
// later to know whether to save data.
|
|
private void textbox_change(object sender, System.EventArgs e)
|
|
{
|
|
if(dosaveflag)mysavexml = true;
|
|
}
|
|
// C2021-026 Event handler for Parent/Child child textbox
|
|
// if the textbox text is same as parent, then or nothing is entered in the textbox
|
|
// then use the parent value and set the text color to gray
|
|
private void txtBox_Leave(object sender, EventArgs e)
|
|
{
|
|
TextBox tb = sender as TextBox;
|
|
string dfTxt = "";
|
|
string parName = pcGrpBox.Name.Substring(5);
|
|
object o = myHT[parName];
|
|
if (o != null)
|
|
dfTxt = (o as TextBox).Text; // set to use the parent's value (default)
|
|
if (dosaveflag) mysavexml = true;
|
|
if (tb.Text.Length == 0 || tb.Text == dfTxt)
|
|
{
|
|
tb.Text = dfTxt;
|
|
tb.ForeColor = SystemColors.GrayText;
|
|
}
|
|
}
|
|
|
|
// C2021-026 Event handler for Parent/Child child textbox
|
|
// If the textbox is set to gray, then we are using the parent value
|
|
// so clear the textbox so that user can enter the value for that child
|
|
private void txtBox_Enter(object sender, EventArgs e)
|
|
{
|
|
TextBox tb = sender as TextBox;
|
|
if (tb.ForeColor == SystemColors.GrayText) // currently no value set - using parent's value
|
|
{
|
|
tb.Text = "";
|
|
tb.ForeColor = SystemColors.WindowText;
|
|
}
|
|
}
|
|
|
|
// radiocheckchg - called when a radio button is selected. This will set
|
|
// visibility for associated text box.
|
|
private void radiocheckchg(object sender, System.EventArgs e)
|
|
{
|
|
RadioButton btnsel = (RadioButton) sender;
|
|
TextBox assocbox;
|
|
string btntext, str;
|
|
|
|
if(dosaveflag)mysavexml = true;
|
|
btntext = CvtUserFldToFld(btnsel.Text);
|
|
|
|
// now get the actual textbox and set visibility depending
|
|
// on whether the box is checked, i.e. turned on(if checked, it should
|
|
// be set to visible)
|
|
|
|
str = btnsel.Name.Replace(btntext,"");
|
|
object o = myHT[str];
|
|
if (o == null) return;
|
|
assocbox = (TextBox) o;
|
|
// make the text box visible if checked, otherwise, invisible
|
|
assocbox.Visible = btnsel.Checked;
|
|
// C2021-026 show or hide the Parent/Child appicability group box
|
|
if (pcGrpBox != null) // note that we save only one applicability group box and only for the schema choice field type (radio buttons)
|
|
{
|
|
bool vsblState = (btnsel.Text == "Fixed"); // only show parent/child group if the Fixed radio button is selected
|
|
{
|
|
pcGrpBox.Visible = vsblState; // show or hide the P/C Children group box (the box shaded in blue)
|
|
// C2021-026 PCChildren contains a list strings reprenting the Children setup in the current Working Draft Parent/Child property
|
|
int pcChildIdx = 0;
|
|
foreach (string s in PCChildren)
|
|
{
|
|
pcChildIdx++;
|
|
string fldx = string.Format("_PCCHILD{0}", pcChildIdx); // create a field name for P/C Child fields
|
|
string tstr = pcGrpBox.Name.Substring(5) + fldx; // get the base part of the label and text box control name
|
|
foreach (Control c in Controls)
|
|
if (c.Name == tstr)
|
|
{
|
|
c.Visible = vsblState; // show or hide the lable inside the group box
|
|
object oo = myHT[c.Name];
|
|
if (oo != null)
|
|
(oo as TextBox).Visible = vsblState; // show or hide the associated text box
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// these two methods convert user input field names from/to xml tags. (xml tags
|
|
// cannot begin with digit, have spaces or other special chars.
|
|
private string CvtUserFldToFld(string fldname)
|
|
{
|
|
if (fldname.Length < 2)
|
|
return fldname;
|
|
// a digit cannot start an xml fieldname, prepend a "__" to it.
|
|
string tmp0;
|
|
if (char.IsDigit(fldname,0))
|
|
tmp0 = "__" + fldname;
|
|
else
|
|
tmp0 = fldname;
|
|
// an xml fieldname cannot have a space, change it to a "__"
|
|
string tmpstr = tmp0.Replace(" ","__");
|
|
int len = tmpstr.Length;
|
|
int cnt = 0;
|
|
|
|
// this is also our sequence that tells us the follow 3 digits is the ascii number (base 10)
|
|
// of the character we replaced.
|
|
string OKpunch = "-._";
|
|
|
|
string outstr = "";
|
|
int decval;
|
|
|
|
while (cnt < len)
|
|
{
|
|
char tmpchr = tmpstr[cnt];
|
|
if(!char.IsLetterOrDigit(tmpchr)&& (OKpunch.IndexOf(tmpchr) == -1) )
|
|
{
|
|
decval = tmpchr;
|
|
outstr += OKpunch + decval.ToString("D3");
|
|
}
|
|
else
|
|
{
|
|
outstr += tmpchr.ToString();
|
|
}
|
|
cnt++;
|
|
}
|
|
return outstr;
|
|
}
|
|
|
|
private string CvtFldToUserFld(string fldname)
|
|
{
|
|
string tmpstr0;
|
|
if (fldname.Length < 2) return fldname;
|
|
// an xml element name cannot begin with a digit. we had prepended a "__"
|
|
if (fldname.Substring(0,2) == "__" && char.IsDigit(fldname,2))
|
|
tmpstr0 = fldname.Substring(2,fldname.Length-2);
|
|
else
|
|
tmpstr0 = fldname;
|
|
// an xml element name cannot have a space, we converted to a "__"
|
|
string tmpstr = tmpstr0.Replace("__"," ");
|
|
int len = tmpstr.Length;
|
|
int cur = 0;
|
|
|
|
// this is also our sequence that tells us the follow 3 digits is the ascii number (base 10)
|
|
// of the character we replaced.
|
|
string OKpunch = "-._";
|
|
|
|
string outstr = "";
|
|
int decval, indx;
|
|
if (tmpstr.Length <6)
|
|
indx = -1;
|
|
else
|
|
indx=tmpstr.IndexOf(OKpunch,cur);
|
|
string asc_spchar;
|
|
while (indx>=0)
|
|
{
|
|
outstr += tmpstr.Substring(cur,indx-cur);
|
|
asc_spchar = tmpstr.Substring(indx+3,3);
|
|
decval = System.Convert.ToInt16(asc_spchar,10);
|
|
outstr += System.Convert.ToChar(decval).ToString();
|
|
cur = indx+6;
|
|
if (cur+6 > len)
|
|
indx = -1;
|
|
else
|
|
indx = tmpstr.IndexOf(OKpunch,cur);
|
|
}
|
|
if (cur<len) outstr += tmpstr.Substring(cur,len-cur);
|
|
|
|
return outstr;
|
|
}
|
|
|
|
// The following can be used to validate the text, i.e. check the text against
|
|
// the pattern. this needs written yet (5/16/02)
|
|
private void MyValidatingCode(TextBox tb)
|
|
{
|
|
//get the text box's tag which contains a flag for whether this is required &
|
|
//if it has a pattern. If it has a pattern, validate the field against the pattern.
|
|
TextBoxAttrTag tag;
|
|
tag = (TextBoxAttrTag) tb.Tag;
|
|
string pattern = tag.GetPattern;
|
|
if (pattern != null)
|
|
{
|
|
//see if text in box matches pattern
|
|
// if not throw exception.
|
|
}
|
|
|
|
//USE THE FOLLOWING WHEN CHECKING FOR REQUIRED FIELDS
|
|
|
|
// Confirm there is text in the control.
|
|
//if (textBox1.Text.Length == 0)
|
|
//{
|
|
// throw new Exception("Email address is a required field");
|
|
// }
|
|
// Confirm that there is a "." and an "@" in the e-mail address.
|
|
// else if(textBox1.Text.IndexOf(".") == -1 || textBox1.Text.IndexOf("@") == -1)
|
|
// {
|
|
// throw new Exception("E-mail address must be valid e-mail address format." +
|
|
// "\nFor example 'someone@microsoft.com'");
|
|
// }
|
|
}
|
|
|
|
// save which box we're on, for zoom processing.
|
|
private void textbox_zoombtn(object sender, System.EventArgs e)
|
|
{
|
|
TextBox textbox = (TextBox) sender;
|
|
if (textbox.Multiline == true || textbox == GraphicsFiletextbox)
|
|
zoomtextbox = textbox;
|
|
else
|
|
zoomtextbox = null;
|
|
}
|
|
|
|
private void textbox_Validating(object sender, System.ComponentModel.CancelEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
MyValidatingCode((TextBox) sender);
|
|
}
|
|
|
|
catch(Exception ex)
|
|
{
|
|
// Cancel the event and select the text to be corrected by the user.
|
|
e.Cancel = true;
|
|
MessageBox.Show(ex.ToString(), "Error in validation");
|
|
//textBox1.Select(0, textBox1.Text.Length);
|
|
|
|
// Set the ErrorProvider error with the text to display.
|
|
//this.errorProvider1.SetError(textBox1, ex.Message);
|
|
}
|
|
}
|
|
|
|
private void MyOnKeyDown(object objSender, KeyEventArgs kea)
|
|
{
|
|
if (((kea.Modifiers&Keys.Shift)==Keys.Shift) && kea.KeyCode == Keys.F2)
|
|
{
|
|
if (zoomtextbox == null)
|
|
{
|
|
MessageBox.Show("Must have cursor in text box which should be zoomed.");
|
|
return;
|
|
}
|
|
btnZoom_click(null, null);
|
|
}
|
|
}
|
|
|
|
public void btnZoom_click(object sender, System.EventArgs e)
|
|
{
|
|
//TextBox tb = (TextBox) sender;
|
|
TextBoxAttrTag tag;
|
|
bool doimage = false;
|
|
if (zoomtextbox.Tag != null)
|
|
{
|
|
tag = (TextBoxAttrTag) zoomtextbox.Tag;
|
|
if (tag.GetImageName == "Image" && zoomtextbox.Text != null && zoomtextbox.Text !="") doimage = true;
|
|
}
|
|
if (doimage)
|
|
{
|
|
string GraphicsFileName = zoomtextbox.Text;
|
|
if (GraphicsFileName.IndexOf('.') == -1)
|
|
GraphicsFileName += DefaultGraphicFileExtension; // default graphics file extension
|
|
FileInfo fi = new FileInfo(GraphicsFileName);
|
|
if (fi.Exists == false)
|
|
{
|
|
MessageBox.Show("Cannot view a missing graphics file.","Error");
|
|
return;
|
|
}
|
|
ImageDialog dlg = new ImageDialog(GraphicsFileName);
|
|
dlg.ShowDialog();
|
|
}
|
|
else
|
|
{
|
|
ZoomDialog dlg = new ZoomDialog(zoomtextbox.Text);
|
|
dlg.ShowDialog();
|
|
// Determine the state of the DialogResult property for the form
|
|
if (dlg.DialogResult == DialogResult.OK)
|
|
{
|
|
// Create an instance of the ZoomText object to store the
|
|
// dialog data
|
|
string zt = dlg.ZoomText;
|
|
// Save the text in the text box.
|
|
zoomtextbox.Text = (zt);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// The series of graphic file support were lifted from the old RO editor.
|
|
// They check for file existance, check date/time stamps before moving the
|
|
// file local & keep width/height of file proportional.
|
|
private void GraphicText_lostfocus(object sender, System.EventArgs e)
|
|
{
|
|
TextBox fnamebox = (TextBox) sender;
|
|
if (fnamebox.Text != "" && fnamebox.Modified == true)
|
|
{
|
|
FileInfo ifi = new FileInfo(fnamebox.Text);
|
|
if (ifi.Exists == false)
|
|
{
|
|
FileInfo ifi2 = new FileInfo(fnamebox.Text + DefaultGraphicFileExtension);
|
|
if (!ifi2.Exists)
|
|
{
|
|
MessageBox.Show("File does not exist.",
|
|
"File Input Error", MessageBoxButtons.OK);
|
|
return;
|
|
}
|
|
}
|
|
bool ok = ValidGraphicsFile(fnamebox.Text);
|
|
if (ok != true)
|
|
{
|
|
if (fnamebox.Text != "")fnamebox.Text.Replace(fnamebox.Text,"");
|
|
if (GraphicsWdtextbox.Text != "")GraphicsWdtextbox.Text = "";
|
|
if (GraphicsHttextbox.Text!= "")GraphicsHttextbox.Text = "";
|
|
}
|
|
else
|
|
{
|
|
GraphicsWdtextbox.Enabled = true;
|
|
GraphicsHttextbox.Enabled = true;
|
|
UpdateHtWd();
|
|
}
|
|
}
|
|
if (fnamebox.Text == null || fnamebox.Text == "")
|
|
{
|
|
GraphicsWdtextbox.Enabled = false;
|
|
GraphicsHttextbox.Enabled = false;
|
|
}
|
|
}
|
|
|
|
string CalculatePromsDate(DateTime imgdate)
|
|
{
|
|
/*
|
|
* do some conversion so that proms will be able to use this
|
|
* date/time. Proms had it in seconds since 00:00:00 1/1/1970.
|
|
* .NET has it in ticks since 00:00:00 1/1/1
|
|
*/
|
|
DateTime promsdt = new DateTime(1970,1,1,0,0,0); // Jan 1, 1970
|
|
// Convert the promsdt to UTC (GMT)
|
|
DateTime promsdtU = promsdt.ToUniversalTime();
|
|
long promsdtU_num = promsdtU.Ticks / 10000000;
|
|
|
|
// Convert the image file datetime to UTC
|
|
DateTime imgdateU = imgdate.ToUniversalTime();
|
|
long imgdateu_num = imgdateU.Ticks / 10000000;
|
|
|
|
/**
|
|
* Get the time adjustment for the current Time Zone with respect
|
|
* to the coordinated universal time (UTC) - a.k.a. Greenwich mean time (GMT).
|
|
* The time gotten for the Jan 1, 1970 is in UTC time, the imgdate time is
|
|
* in EST.
|
|
*
|
|
* Get the offset time between this time zone and UTC (GMT) time.
|
|
* Convert the offset to seconds.
|
|
* Subtract the offset from the UTC time gotten for Jan 1, 1970
|
|
*/
|
|
ThisTimeZone TZ = new ThisTimeZone();
|
|
TimeSpan TimeZoneSpan = TZ.GetUtcOffset(promsdt); // Time Zone offset from UTC
|
|
long TimeZoneAdj = Math.Abs(TimeZoneSpan.Ticks / 10000000); // convert to seconds
|
|
|
|
/*
|
|
* The file date/time and the Jan 1, 1970 adjustment date are in UTC.
|
|
* Subtract the "Jan 1, 1970" date/time from the file date/time
|
|
* the add the Time Zone offset to place the date/time value into
|
|
* local time.
|
|
*/
|
|
long lsec = (imgdateu_num - promsdtU_num) + TimeZoneAdj;
|
|
string imgdt = lsec.ToString();
|
|
return imgdt;
|
|
}
|
|
/// Import the GetShortPathName function from the win32 kernel dll. This
|
|
/// is not supported in .net/C#
|
|
[DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Auto)]
|
|
public static extern void GetShortPathName(
|
|
[MarshalAs(UnmanagedType.LPTStr)] string lpszLongPath,
|
|
[MarshalAs(UnmanagedType.LPTStr)] StringBuilder lpszShortPath,
|
|
[MarshalAs(UnmanagedType.U4)] int cchBuffer);
|
|
|
|
private bool ValidGraphicsFile(string GraphicFileName)
|
|
{
|
|
string iname = GraphicFileName;
|
|
if (iname == null || iname == "") return false;
|
|
GraphicsWdtextbox.Enabled = true;
|
|
GraphicsHttextbox.Enabled = true;
|
|
if (iname.IndexOf('.') == -1)
|
|
iname += DefaultGraphicFileExtension; // default graphics file extension
|
|
FileInfo ifi = new FileInfo(iname); // input file & info
|
|
string ext = ifi.Extension; // returns '.bmp' etc
|
|
if (ext == null)
|
|
{
|
|
MessageBox.Show( "Missing file extension.","Error");
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
string Uext = ext.Substring(1,3).ToUpper();
|
|
if (Uext!="BMP"&&Uext!="EMF"&&Uext!="GIF"&&Uext!="ICO"&&Uext!="JPG"&&Uext!="PNG"&&Uext!="TIF"&&Uext!="WMF")
|
|
{
|
|
MessageBoxButtons buttons = MessageBoxButtons.OK;
|
|
//DialogResult result;
|
|
MessageBox.Show( "Not a supported graphics file type.",
|
|
"Unsupported extension.", buttons);
|
|
return false;
|
|
}
|
|
|
|
// Get the path and filename. ptr points to just the filename
|
|
int slindx;
|
|
string lname;
|
|
slindx = iname.LastIndexOf("\\");
|
|
if (slindx >0)
|
|
lname = iname.Substring(slindx+1,iname.Length-slindx-1);
|
|
else
|
|
lname = iname;
|
|
// now check to see if this is a local file - to do this, check
|
|
// to see if either has a "~" which may signify a short filename.
|
|
// If so, compare the short file names (Note that comparing long
|
|
// filenames didn't work, i.e. the kernel routine did not return
|
|
// a long filename if a short one was sent in).
|
|
|
|
// open an existing file, or create a new one
|
|
|
|
FileInfo lfi = new FileInfo(lname); // local file & info
|
|
|
|
if (lfi.Exists == false) // !exist, copy it & move on
|
|
{
|
|
// Copy the file to the local directory
|
|
ifi.CopyTo(lname);
|
|
// update fields on window....
|
|
GraphicsFiletextbox.Text = lfi.Name;
|
|
TextBoxAttrTag tag = (TextBoxAttrTag) GraphicsFiletextbox.Tag;
|
|
tag.SetImageDate(CalculatePromsDate(ifi.LastWriteTime));
|
|
GraphicsFiletextbox.Tag = tag;
|
|
UpdateHtWd();
|
|
return true;
|
|
}
|
|
else // A local file exists by the same name
|
|
{
|
|
if (ifi.Exists == false)
|
|
{
|
|
MessageBox.Show("Input file doesn't exist.","Error");
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// first just check if these are really the same, just the
|
|
// user put a path in.
|
|
int same = 0;
|
|
if (ifi.DirectoryName.IndexOf("~")>=0 || lfi.DirectoryName.IndexOf("~")>=0)
|
|
{
|
|
|
|
StringBuilder shortlname = new StringBuilder(257);
|
|
StringBuilder shortiname = new StringBuilder(257);
|
|
GetShortPathName(ifi.DirectoryName,shortiname,257);
|
|
GetShortPathName(lfi.DirectoryName,shortlname,257);
|
|
same = String.Compare(shortlname.ToString(),shortlname.ToString());
|
|
}
|
|
if (same == 0)
|
|
{
|
|
TextBoxAttrTag tag = (TextBoxAttrTag) GraphicsFiletextbox.Tag;
|
|
tag.SetImageDate(CalculatePromsDate(lfi.LastWriteTime));
|
|
GraphicsFiletextbox.Tag = tag;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Is the file the same - size, date, time
|
|
// old code checked for both findfirst failures??
|
|
string msg=null;
|
|
if (lfi.LastWriteTime > ifi.LastWriteTime)
|
|
msg = "A newer copy of t";
|
|
else if (lfi.LastWriteTime < ifi.LastWriteTime)
|
|
msg = "An older copy of t";
|
|
else if (lfi.Length != ifi.Length)
|
|
msg = "A different copy of t";
|
|
msg = msg + "he selected file\nexists in the RO directory\n";
|
|
msg = msg + "Do you want to replace it\n";
|
|
msg = msg + "with the selected file?";
|
|
MessageBoxButtons buttons = MessageBoxButtons.YesNoCancel;
|
|
DialogResult result;
|
|
result = MessageBox.Show( msg, "Graphics File Copy", buttons);
|
|
if (result == DialogResult.Yes)
|
|
{
|
|
lfi.Delete();
|
|
ifi.CopyTo(lname,true);
|
|
// update dialog data & ht/wd
|
|
GraphicsFiletextbox.Text = lfi.Name;
|
|
TextBoxAttrTag tag = (TextBoxAttrTag) GraphicsFiletextbox.Tag;
|
|
tag.SetImageDate(CalculatePromsDate(lfi.LastWriteTime));
|
|
GraphicsFiletextbox.Tag = tag;
|
|
UpdateHtWd();
|
|
return true;
|
|
}
|
|
else if (result != DialogResult.No) // not yes or no. Cancel out.
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// if changed height, calculate associated width
|
|
private void GraphicsHt_lostfocus(object sender, System.EventArgs e)
|
|
{
|
|
TextBox ht = (TextBox) sender;
|
|
if (ht.Modified == true)
|
|
{
|
|
try
|
|
{
|
|
int newht= System.Convert.ToInt32(ht.Text);
|
|
setHtWdBasedUponHeight(newht);
|
|
}
|
|
catch (Exception ee)
|
|
{
|
|
MessageBox.Show("The Height and Width cannot be empty fields. Enter a number in either field and the other will automatically adjust to a proportional size.", "Invalid Height Input");
|
|
}
|
|
}
|
|
}
|
|
// if changed width, calculate associated height
|
|
private void GraphicsWd_lostfocus(object sender, System.EventArgs e)
|
|
{
|
|
TextBox wd = (TextBox) sender;
|
|
if (wd.Modified == true)
|
|
{
|
|
try
|
|
{
|
|
int newwd= System.Convert.ToInt32(wd.Text);
|
|
setHtWdBasedUponWidth(newwd);
|
|
}
|
|
catch (Exception ee)
|
|
{
|
|
MessageBox.Show("The Height and Width cannot be empty fields. Enter a number in either field and the other will automatically adjust to a proportional size.", "Invalid Width Input");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setHtWdBasedUponHeight(int nuval)
|
|
{
|
|
int w,h;
|
|
if(himage!=0)
|
|
{
|
|
if(nuval==0)nuval=(himage+DPPL-1)/DPPL;
|
|
if(nuval > hmax)nuval=hmax;
|
|
else if(nuval < hmin)nuval=hmin;
|
|
h=nuval;
|
|
// The <<1, +1, and >>1 efectively round the result
|
|
// by multiplying by 2 performing the division adding
|
|
// 1 and dividing by 2
|
|
w=(((h*STDCPI*wimage)<<1)/(himage*STDLPI)+1)>>1;
|
|
}
|
|
else
|
|
{
|
|
w=h=0;
|
|
}
|
|
GraphicsWdtextbox.Text = w.ToString();
|
|
GraphicsHttextbox.Text = h.ToString();
|
|
}
|
|
|
|
private void setHtWdBasedUponWidth(int nuval)
|
|
{
|
|
int w,h;
|
|
if(himage!=0)
|
|
{
|
|
if(nuval==0)nuval=(wimage+DPPC-1)/DPPC;
|
|
if(nuval > wmax)nuval=wmax;
|
|
else if(nuval < wmin)nuval=wmin;
|
|
w=nuval;
|
|
//
|
|
// The <<1, +1, and >>1 efectively round the result
|
|
// by multiplying by 2 performing the division adding
|
|
// 1 and dividing by 2
|
|
h=(((w*STDLPI*himage)<<1)/(wimage*STDCPI)+1)>>1;
|
|
}
|
|
else
|
|
{
|
|
w=h=0;
|
|
}
|
|
GraphicsWdtextbox.Text = w.ToString();
|
|
GraphicsHttextbox.Text = h.ToString();
|
|
}
|
|
|
|
private void UpdateHtWd()
|
|
{
|
|
// copy the file local and also get it's width/height by reading the file.
|
|
Bitmap image;
|
|
|
|
try
|
|
{
|
|
string dir = Directory.GetCurrentDirectory();
|
|
string GraphicsFileName = GraphicsFiletextbox.Text;
|
|
// FileInfo fi = new FileInfo(GraphicsFiletextbox.Text);
|
|
if (GraphicsFileName.IndexOf('.') == -1)
|
|
GraphicsFileName += DefaultGraphicFileExtension; // default graphics file extension
|
|
FileInfo fi = new FileInfo(GraphicsFileName);
|
|
if (fi.Exists == false)
|
|
{
|
|
MessageBox.Show("Graphics File is missing","Error");
|
|
wimage=himage=height=width=0;
|
|
return;
|
|
}
|
|
|
|
image = new Bitmap(GraphicsFileName);
|
|
himage = image.Height;
|
|
wimage = image.Width;
|
|
hmax=MAXLT; // 60 Lines
|
|
int hmxw=STDLPI*MAXWT*himage/(wimage*STDCPI);
|
|
if(hmxw < hmax)
|
|
{// Size is limited to the width of the paper
|
|
hmax=hmxw;
|
|
wmax=MAXWT;
|
|
}
|
|
else
|
|
{
|
|
wmax=STDCPI*hmax*wimage/(himage*STDLPI);
|
|
}
|
|
hmin=1;
|
|
int hmnw=STDLPI*6*himage/(wimage*STDCPI);
|
|
if(hmnw > hmin)
|
|
{// Size is limited by the width of the graphic
|
|
hmin=hmnw;
|
|
wmin=6;
|
|
}
|
|
else
|
|
{
|
|
wmin=STDCPI*1*wimage/(himage*STDLPI);
|
|
}
|
|
setHtWdBasedUponHeight(height);
|
|
}
|
|
catch (Exception exx)
|
|
{
|
|
MessageBox.Show(exx.Message.ToString(),"error on processing of graphics file");
|
|
}
|
|
}
|
|
|
|
private void btnFindFile_click(object sender, System.EventArgs e)
|
|
{
|
|
bool done = false;
|
|
while (done == false)
|
|
{
|
|
OpenFileDialog openFileDialog1 = new OpenFileDialog();
|
|
openFileDialog1.InitialDirectory = Directory.GetCurrentDirectory();
|
|
openFileDialog1.Filter =
|
|
"Bitmap files (*.bmp)|*.bmp|Enhanced Windows metafiles (*.emf)|*.emf|Graphics Interchange Format (*.gif)|*.gif|Icons (*.ico)|*.ico|JPEG (*.jpg)|*.jpg|Portable Network Graphics (*.png)|*.png|TIFF (*.tif)|*.tif|Windows Metafile (*.wmf)|*.wmf" ;
|
|
openFileDialog1.FilterIndex = 7 ;
|
|
openFileDialog1.RestoreDirectory = true ;
|
|
openFileDialog1.CheckFileExists = true;
|
|
// try
|
|
// {
|
|
if(openFileDialog1.ShowDialog() != DialogResult.OK)
|
|
done = true;
|
|
else
|
|
{
|
|
string iname = openFileDialog1.FileName;
|
|
done = ValidGraphicsFile(iname);
|
|
if (done == true)
|
|
{
|
|
FileInfo fi = new FileInfo(iname);
|
|
GraphicsFiletextbox.Text = fi.Name;
|
|
UpdateHtWd();
|
|
}
|
|
}
|
|
// }
|
|
// catch (Exception j)
|
|
// {
|
|
// MessageBox.Show(j.Message,"debug");
|
|
// }
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/*
|
|
* TimeZone is an Abstract Class. You need to inherit the TimeZone Class
|
|
* and overload a couple of it's functions in order to use it.
|
|
* - called in CalculatePromsDate() above.
|
|
*/
|
|
public class ThisTimeZone : TimeZone
|
|
{
|
|
private TimeZone curTZ;
|
|
public TimeSpan SpanTZ;
|
|
|
|
public ThisTimeZone()
|
|
{
|
|
curTZ = CurrentTimeZone; // local timezone
|
|
}
|
|
|
|
// get the UTC (GMT) value for the given date/time
|
|
public override TimeSpan GetUtcOffset(DateTime ForThisDate)
|
|
{
|
|
SpanTZ = curTZ.GetUtcOffset(ForThisDate);
|
|
return SpanTZ;
|
|
}
|
|
|
|
// Name of the local Daylight savings time zone
|
|
public override string DaylightName
|
|
{
|
|
get
|
|
{
|
|
return curTZ.DaylightName;
|
|
}
|
|
}
|
|
|
|
// Name of the local standard time zone
|
|
public override string StandardName
|
|
{
|
|
get
|
|
{
|
|
return curTZ.StandardName;
|
|
}
|
|
}
|
|
|
|
// Get the start and end dates for daylight savings
|
|
public override System.Globalization.DaylightTime GetDaylightChanges(int year)
|
|
{
|
|
return curTZ.GetDaylightChanges(year);
|
|
}
|
|
}
|
|
}
|
|
|