Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
f3c8c860f59929b2721432fc262631b742500ad2
SourceCode/PROMS/Volian.Controls.Library/GridItem.cs

1355 lines
47 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Text.RegularExpressions;
//using System.IO;
using System.Windows.Forms;
using System.Xml;
using VEPROMS.CSLA.Library;
using Volian.Base.Library;
using C1.Win.C1FlexGrid;
using JR.Utils.GUI.Forms;
namespace Volian.Controls.Library
{
public partial class GridItem : EditItem
{
#region Fields
private DocVersionInfo _MyDVI = null;
public DocVersionInfo MyDVI
{
get
{
ItemInfo procInfo = MyItemInfo.MyProcedure as ItemInfo;
if (procInfo == null)
_MyDVI = null;
else
_MyDVI = procInfo.ActiveParent as DocVersionInfo;
return _MyDVI;
}
}
private static UserInfo _MyUserInfo = null;
public static UserInfo MyUserInfo
{
get { return _MyUserInfo; }
set { _MyUserInfo = value; }
}
private bool _IsSaving;
public bool IsSaving
{
get { return _IsSaving; }
set { _IsSaving = value; }
}
public VlnFlexGrid MyFlexGrid
{
get { return _MyFlexGrid; }
set { _MyFlexGrid = value; }
}
private int _GridMargin = 11;
/// <summary>
/// Margin between the EditItem and the VlnFlexGrid. Appears on the Right.
/// Will allow space to draw a Change Bar on the right side of the EditItem.
/// </summary>
public int GridMargin
{
get { return _GridMargin; }
set { _GridMargin = value; }
}
#endregion
#region Event Handlers
/// <summary>
/// Raises an ItemClick event when the user clicks on the Tab
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void lblTab_MouseDown(object sender, MouseEventArgs e)
{
MyStepPanel.OnItemClick(this, new StepPanelEventArgs(this, e));
}
void MyFlexGrid_Resize(object sender, EventArgs e)
{
if (MyFlexGrid.ReadingXml) return;
this.Size = new Size(MyFlexGrid.Width + GridMargin, MyFlexGrid.Height + GridMargin);
AdjustTableWidthAndLocation();
AdjustLocation();
}
void MyFlexGrid_Enter(object sender, EventArgs e)
{
if (MyStepPanel.DisplayItemChanging) return;
MyStepRTB.MyItemInfo = MyItemInfo; // should be in vlnFlexGrid
MyStepPanel.SelectedEditItem = this;
if (!UserInfo.CanEdit(MyUserInfo,MyDVI))
{
MyFlexGrid.Cols.Fixed = MyFlexGrid.Cols.Count;
MyFlexGrid.Rows.Fixed = MyFlexGrid.Rows.Count;
}
}
void MyFlexGrid_KeyDown(object sender, KeyEventArgs e)
{
switch (e.KeyCode)
{
case Keys.F5:
if (e.Shift)
{
e.Handled = true;
if (!CheckClipboard()) return; // check if 'clipboard' contains a step.
SetMenu("StepPaste");
}
else if (!e.Control && !e.Alt)
{
e.Handled = true;
CopyStep();
}
break;
case Keys.Delete:
if (!MyFlexGrid.IsRoTable)
MyFlexGrid.ClearSelectedCellText();
break;
}
}
void SetMenu(string contentMenu)
{
if (contentMenu == null)
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.ClearContextMenu();
else if (contentMenu == "OpenContextMenu")
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetGridCellContextMenu(); //.SetContextMenu();
else
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetShortCutContextMenu(contentMenu);
}
void MyFlexGrid_CursorMovement(object sender, VlnFlexGridCursorMovementEventArgs args)
{
MyStepPanel.CursorMovement(this,new Point(0,0), args.Key);
}
void MyStepRTB_LinkModifyTran(object sender, StepPanelLinkEventArgs args)
{
MyStepPanel.OnLinkModifyTran(sender, args);
}
void MyStepRTB_LinkModifyRO(object sender, StepPanelLinkEventArgs args)
{
MyStepPanel.OnLinkModifyRO(sender, args);
}
void MyStepRTB_LinkGoTo(object sender, StepPanelLinkEventArgs args)
{
MyStepPanel.OnLinkClicked(sender, args);
}
void MyStepRTB_CursorKeyPress(object sender, KeyEventArgs args)
{
MyStepPanel.StepCursorKeys(this, args);
}
void MyStepRTB_AdjustTableWidth(object sender, StepRTBTableWidthEventArgs args)
{
//Console.WriteLine("MyStepRTB_AdjustTableWidth");
//if ((!_MyItemInfo.IsSection && !_MyItemInfo.IsProcedure) && (_MyItemInfo.IsTable || _MyItemInfo.IsFigure))
if (args.EditMode)
{
int colR = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColRTable, MyItemInfo.ColumnMode);
int widS = /* _WidthAdjust + borderWidth + */ MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, MyItemInfo.ColumnMode);
int wNew = 70 + widS + colR * MyItemInfo.ColumnMode;
if (wNew > ItemWidth)
{
ItemWidth = wNew;
ItemLocation = TableLocation(MyStepSectionLayoutData, wNew);
}
}
else
{
int newwidth = MyFlexGrid.Width;
if (ItemWidth != newwidth)
{
ItemWidth = newwidth;
ItemLocation = TableLocation( MyStepSectionLayoutData, newwidth);
}
}
}
bool MyStepRTB_IsNotCurrentSelection(object sender, EventArgs args)
{
return MyStepPanel.SelectedEditItem != this;
}
void MyStepRTB_OpenAnnotations(object sender, EventArgs args)
{
OpenAnnotations();
}
void MyFlexGrid_OpenAnnotations(object sender, EventArgs args)
{
OpenAnnotations();
}
void MyStepRTB_DoMouseWheel(object sender, MouseEventArgs args)
{
DoMouseWheel(args);
}
void MyStepRTB_DoSaveContents(object sender, EventArgs args)
{
SaveCurrentAndContents();
}
void MyStepRTB_VisibleChanged(object sender, EventArgs e)
{
if (MyStepRTB == null) return;
MyStepRTB.EditMode = MyStepRTB.Visible;
//Console.WriteLine("MyStepRTB_VisibleChanged {0}", MyStepRTB.Width);
//Console.WriteLine("GridItem: EditMode = {0}", MyStepRTB.EditMode);
}
void MyStepRTB_ReturnToEditor(object sender, EventArgs args)
{
//Console.WriteLine("MyStepRTB_ReturnToEditor");
MyFlexGrid.Focus();
MyFlexGrid.StartEditing();
}
void MyFlexGrid_Click(object sender, EventArgs e)
{
MyFlexGrid.Focus();
//MyStepPanel.MyStepTabPanel.MyStepTabRibbon.ToggleTableDesignButtons(false);
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetRibbonForGrid();
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetTableButtonsForMergeRangeSelection();
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetGridContextMenu();
}
void MyStepRTB_EditModeChanged(object sender, EventArgs args)
{
//Console.WriteLine("MyStepRTB_EditModeChanged");
AdjustColorsForEditMode();
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetRibbonForGrid();
}
private void AdjustColorsForEditMode()
{
MyFlexGrid.StyleBackColor = Color.White;
if (MyStepRTB.EditMode)
{
MyFlexGrid.Styles["Focus"].ForeColor = MyFlexGrid.Styles["Focus"].BackColor =
MyFlexGrid.Styles["Highlight"].ForeColor = MyFlexGrid.Styles["Highlight"].BackColor = Color.SkyBlue;
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetRibbonForGridCellIndent();
}
else
{
MyFlexGrid.Styles["Focus"].ForeColor = MyFlexGrid.Styles["Highlight"].ForeColor = Color.Black;
MyFlexGrid.Styles["Focus"].BackColor = MyFlexGrid.Styles["Highlight"].BackColor = Color.LightCyan;
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetRibbonForGridCellIndentClear();
}
}
private string _OrigRtf; // used to store original rtf to allow for 'escape' key restore
void MyFlexGrid_SelChange(object sender, EventArgs e)
{
//if (Initializing) return;
//Volian.Base.Library.vlnStackTrace.ShowStackLocal("MyFlexGrid_SelChange {0}",MyFlexGrid.Selection);
RTBLastFocus = false;
MyStepRTB.Visible = false; // Hide the editor if the Selection Changes
if (Initializing) return;
if (MyFlexGrid.Selection.IsSingleCell && MyFlexGrid.Row >= 0 && MyFlexGrid.Col >= 0)
{
// B2020-088: get string using method in case of merged cells
string rtf = MyFlexGrid.GetCellRTFString(MyFlexGrid.Row, MyFlexGrid.Col);
_OrigRtf = rtf == null ? string.Empty : rtf;
}
}
void MyStepRTB_KeyDown(object sender, KeyEventArgs e)
{
if (!e.Control && !e.Shift && !e.Alt && e.KeyCode == Keys.Escape && MyStepRTB.EditMode)
{
MyStepRTB.Rtf = _OrigRtf;
MyFlexGrid.Select(MyFlexGrid.Selection);
}
}
private string MyFlexGrid_AdjustPastedText(object sender, VlnFlexGridPasteEventArgs args)
{
string tmpForLink = args.Text;
tmpForLink = Regex.Replace(tmpForLink, @"#Link:ReferencedObject:[0-9]+ ", @"#Link:ReferencedObject:<NewID> ");
tmpForLink = Regex.Replace(tmpForLink, @"#Link:Transition:([0-9]+) [0-9]+ ", @"#Link:Transition:$1 <NewID> ");
tmpForLink = Regex.Replace(tmpForLink, @"#Link:TransitionRange:([0-9]+) [0-9]+ ", @"#Link:TransitionRange:$1 <NewID> ");
return tmpForLink;
}
#endregion // Event Handlers
#region Constructors
public GridItem()
{
InitializeComponent();
}
public GridItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand)
{
InitializeComponent();
SetupEventHandlers();
SetupEditItem(itemInfo, myStepPanel, myParentEditItem, myChildRelation, expand, null, false);
}
public GridItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand, EditItem nextEditItem)
{
InitializeComponent();
SetupEventHandlers();
SetupEditItem(itemInfo, myStepPanel, myParentEditItem, myChildRelation, expand, nextEditItem, false);
}
private void SetupEventHandlers()
{
this.MyFlexGrid.Resize += new EventHandler(MyFlexGrid_Resize);
this.MyFlexGrid.Enter += new EventHandler(MyFlexGrid_Enter);
this.MyFlexGrid.Leave += MyFlexGrid_Leave;
this.MyFlexGrid.CursorMovement += new VlnFlexGridCursorMovementEvent(MyFlexGrid_CursorMovement);
this.MyFlexGrid.OpenAnnotations += new VlnFlexGridEvent(MyFlexGrid_OpenAnnotations);
this.MyFlexGrid.KeyDown +=new KeyEventHandler(MyFlexGrid_KeyDown);
this.MyStepRTB.LinkGoTo += new StepRTBLinkEvent(MyStepRTB_LinkGoTo);
this.MyStepRTB.LinkModifyRO += new StepRTBLinkEvent(MyStepRTB_LinkModifyRO);
this.MyStepRTB.LinkModifyTran += new StepRTBLinkEvent(MyStepRTB_LinkModifyTran);
this.MyStepRTB.CursorKeyPress += new StepRTBCursorKeysEvent(MyStepRTB_CursorKeyPress);
this.MyStepRTB.AdjustTableWidth += new StepRTBTableWidthEvent(MyStepRTB_AdjustTableWidth);
this.MyStepRTB.IsNotCurrentSelection += new StepRTBBooleanEvent(MyStepRTB_IsNotCurrentSelection);
this.MyStepRTB.OpenAnnotations += new StepRTBEvent(MyStepRTB_OpenAnnotations);
this.MyStepRTB.DoMouseWheel += new StepRTBMouseEvent(MyStepRTB_DoMouseWheel);
this.MyStepRTB.DoSaveContents += new StepRTBEvent(MyStepRTB_DoSaveContents);
this.MyStepRTB.VisibleChanged += new EventHandler(MyStepRTB_VisibleChanged);
this.MyStepRTB.ReturnToEditor += new StepRTBEvent(MyStepRTB_ReturnToEditor);
this.MyFlexGrid.Click += new EventHandler(MyFlexGrid_Click);
this.MyStepRTB.EditModeChanged += new StepRTBEvent(MyStepRTB_EditModeChanged);
this.MyStepRTB.KeyDown += new KeyEventHandler(MyStepRTB_KeyDown);
this.MyFlexGrid.SelChange += new EventHandler(MyFlexGrid_SelChange);
this.MyStepRTB.GotFocus += new EventHandler(MyStepRTB_GotFocus);
this.MyStepRTB.RoInsert += new StepRTBRoEvent(MyStepRTB_RoInsert);
this.MyFlexGrid.AdjustPastedText += new VlnFlexGridPasteEvent(MyFlexGrid_AdjustPastedText);
this.MyStepRTB.SetMenu += new StepRTBMenuEvent(MyStepRTB_SetMenu);
this.MyStepRTB.OpenContextMenu += new StepRTBLocationEvent(MyStepRTB_OpenContextMenu);
this.MyFlexGrid.EnterKeyPressed += new VlnFlexGridkeyEvent(MyFlexGrid_EnterKeyPressed);
//this.MyStepRTB.EnterKeyPressed += new StepRTBCursorKeysEvent(MyStepRTB_EnterKeyPressed);
// This Resize event has been useful for debugging purposes numerous times
//
//this.MyStepRTB.Resize += new EventHandler(MyStepRTB_Resize);
}
void MyFlexGrid_Leave(object sender, EventArgs e)
{
// MyFlexGrid_Leave appears to be a consistent event that occurs when leaving
// flex grid whether if last cell was in edit or view mode.
// if ContainsFocus is true, then flexgrid still contains focus, so don't change
// any cell colors - otherwise set back to inactive.
if (this.ContainsFocus) return;
CellStyle cs = MyFlexGrid.Styles["Focus"];
cs.ForeColor = Color.Black;
cs = MyFlexGrid.Styles["Highlight"];
cs.ForeColor = Color.Black;
cs.BackColor = MyFlexGrid.MyShading.GetColor(MyFlexGrid.Row, MyFlexGrid.Col); // C2021-004 reset the last active table cell's shading color when leaving
}
//void MyStepRTB_EnterKeyPressed(object sender, KeyEventArgs args)
//{
// args.Handled = true;
// MyStepPanel.MyStepTabPanel.MyStepTabRibbon.ProcessEnterKey();
//}
void MyFlexGrid_EnterKeyPressed(object sender, KeyEventArgs args)
{
args.Handled = true;
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.ProcessEnterKey();
}
void MyStepRTB_OpenContextMenu(object sender, StepRTBLocationEventArgs args)
{
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.OpenContextMenu(args.Location, sender);
}
void MyStepRTB_SetMenu(object sender, StepRTBMenuEventArgs args)
{
SetMenu(args.MenuGroup);
}
// This Resize event been useful for debugging purposes numerous times
//
//void MyStepRTB_Resize(object sender, EventArgs e)
//{
// if (MyStepRTB.Visible)
// {
// //Volian.Base.Library.vlnStackTrace.ShowStack("MyStepRTB_Resize");
// Console.WriteLine("MyStepRTB_Resize {0}", MyStepRTB.Width);
// }
//}
void MyStepRTB_RoInsert(object sender, StepRTBRoEventArgs args)
{
//Console.WriteLine("GridItem - Enter MyStepRTB_RoInsert");
if (MyFlexGrid.IsRoTable)
{
MyFlexGrid.Visible = false;
MyFlexGrid.ConvertTableROToGrid(args.ValText, args.RODbID, args.ROID);
MyFlexGrid.FixTableCellsHeightWidth();
MyFlexGrid.AdjustGridControlSize();
MyFlexGrid.Visible = true;
//MyFlexGrid.MergedRanges.Clear();
//MyFlexGrid.Clear();
//ConvertTableToGrid(args.RawValText, args.RODbID, args.ROID);
//MyFlexGrid.RODbId = args.RODbID;
//MyFlexGrid.ROID = args.ROID;
//SaveContents();
}
else
{
int sel = MyStepRTB.SelectionStart + args.ValText.Length;// +args.LinkText.Length;//MyStepRTB.SelectionLength; // Remember where the link is being added
//Console.WriteLine("ValText {0} LinkText {1}", args.ValText, args.LinkText);
//Console.WriteLine("selstart {0} len {1}", MyStepRTB.SelectionStart, args.LinkText.Length);
CellRange cr = MyFlexGrid.Selection;
MyStepRTB.UpdateStepRtb(args.LinkText, args.ValText);
MyFlexGrid.StartEditing(cr.r1, cr.c1); // get back to edit mode
MyStepRTB.Select(sel, 0);// Move cursor to end of LINK
SendKeys.Send("{RIGHT}"); // this will un-select the RO
SendKeys.Flush();
}
//Console.WriteLine("GridItem - Exit MyStepRTB_RoInsert");
}
void MyStepRTB_GotFocus(object sender, EventArgs e)
{
RTBLastFocus = true;
}
#endregion
#region Override Method and Properties
public override int BorderWidth { get { return (MyFlexGrid.Width - MyFlexGrid.ClientRectangle.Width); } }
//private bool _OnlyOnce = false;
//protected override void OnPaint(PaintEventArgs e)
//{
// base.OnPaint(e);
// if (!this.Enabled && !_OnlyOnce)
// {
// _OnlyOnce = true;
// _MyDisablePanel.SendToBack();
// _MyDisablePanel.BringToFront();
// _OnlyOnce = false;
// }
//}
protected override void OnEnabledChanged(EventArgs e)
{
base.OnEnabledChanged(e);
if (this.Enabled)
{
_MyDisablePanel.SendToBack();
_MyDisablePanel.Visible = false;
}
else
{
_MyDisablePanel.Visible = true;
Rectangle rect = new Rectangle(0, 0, this.MyFlexGrid.Width, this.MyFlexGrid.Height);
Bitmap bmp = new Bitmap(this.MyFlexGrid.Width, this.MyFlexGrid.Height);
this.MyFlexGrid.DrawToBitmap(bmp, rect);
using (Graphics gr = Graphics.FromImage(bmp))
{
gr.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceOver;
gr.FillRectangle(new SolidBrush(Color.FromArgb(128, Color.FromKnownColor(KnownColor.ButtonFace))), rect);
//gr.FillEllipse(Brushes.Red, 10, 10, 10, 10);
}
_MyDisablePanel.Location = this.MyFlexGrid.Location;
_MyDisablePanel.Size = this.MyFlexGrid.Size;
_MyDisablePanel.BackgroundImage = bmp;
_MyDisablePanel.BringToFront();
}
}
public override Point ContentLocation
{
get { return new Point(Location.X + MyFlexGrid.Left, Location.Y); }
set { Location = new Point(value.X - MyFlexGrid.Left, value.Y); }
}
public override string TabFormat { get { return _TabFormat; } set { _TabFormat = value; } }
public override void AdjustTableWidthAndLocation()
{
//_MyStepRTB.Font = MyStepData.Font.WindowsFont;
//ItemWidth = (int)GetTableWidth(MyStepRTB.Font, MyItemInfo.MyContent.Text, true);
//ItemWidth = MyFlexGrid.Width;
//ItemLocation = new Point(50, _MyParentEditItem.Bottom);
// We had a table that was in a funky state. This allows it to appear in editor so
// that is could be deleted.
if (_MyParentEditItem == null) return;
Point newLocation = TableLocation(MyStepSectionLayoutData, ItemWidth);
if (!newLocation.Equals(ItemLocation)) ItemLocation = newLocation;
}
public override void SetToolTip(string tip)
{
DevComponents.DotNetBar.SuperTooltipInfo tpi = new DevComponents.DotNetBar.SuperTooltipInfo("", "", tip, null, null, DevComponents.DotNetBar.eTooltipColor.Lemon);
_MyToolTip.MinimumTooltipSize = new Size(0, 24);
_MyToolTip.TooltipDuration = 3;
_MyToolTip.SetSuperTooltip(MyFlexGrid, tpi);
ToolTipOnOff(); // B2025-050 Show the tooltip based on User Options Settings
}
public override void ToolTipOnOff()
{
_MyToolTip.Enabled = VlnSettings.StepTypeToolTip; // B2025-XXX Show the tooltip based on User Options Settings
}
private bool DoNotRefresh = false;
public override void RefreshContent()
{
if (DoNotRefresh) return;
_ActiveMode = MyFlexGrid.ContainsFocus;
using (Grid myGrid = MyItemInfo.MyContent.MyGrid.Get())
{
MyItemInfo.MyContent.MyGrid.ResetContent(myGrid);
}
RefreshDisplay(_ActiveMode);
IdentifyMe(false);
}
public override int TableWidth { get { return 0; } } // DONE
public override int ItemLeft
{
get { return Left + lblTab.Left; }
set { Left = value - lblTab.Left; }
}
public override int ContentLeft { get { return Left + MyFlexGrid.Left; } }
public override int ContentWidth
{
get { return MyFlexGrid.Width; }
set
{
Width = value + lblTab.Left + lblTab.Width;
}
}
public override Point ItemLocation
{
get { return new Point(Location.X + lblTab.Left, Location.Y); }
set { Location = new Point(value.X - lblTab.Left, value.Y); }
}
public override int ItemWidth
{
get { return Width - lblTab.Left; }
set
{
Width = GridMargin + value + lblTab.Left;
}
}
public override void RefreshOrdinal()
{
TabFormat = null; // Reset Tab
}
public override bool Expanded
{
get {return !Colapsing;}
set {;} // Tables are always expanded.
}
public override void RefreshTab() { TabFormat = null;}
public override void SetFocus() { MyFlexGrid.Focus();}
public override void SaveContents()
{
if (!MyFlexGrid.IsDirty && !IsSaving) return;
List<int> RtfRoUsageList = new List<int>();
List<int> RtfTransList = new List<int>();
List<int> RtfTransPageNumList = new List<int>();
int r = 0;
int c = 0;
int w = MyFlexGrid.Cols.Count;
int h = MyFlexGrid.Rows.Count;
string srchtxt = MyFlexGrid.GetSearchableText();
// find the rousages within the grid cell. If this is an ro table, there will only be one usage
// if it is a modify and there will be no usages if it is new (the usage gets created on the save)
if (!MyFlexGrid.IsRoTable)
{
while (r < h)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
if (MyFlexGrid[r, c] != null)
{
// see if there are any links and save these so that any deleted ROs or transitions in the
// steprtb can have associated usages/transitions records removed from the database.
string lookFor = string.Format(@"<START\](\\[^v \\]+)*\\v0(\\[^v '?{{}}~\\]+)*( |\\u[0-9]{{1,4}}?|\\'[0-9a-fA-F]{{2}}|\\[{{}}~])(.*?)(\\[^v '?{{}}~\\]+)*\\v(\\[^v \\]+)* #Link:(ReferencedObject|Transition[^:]*?):.*?\[END>");
MatchCollection matches = Regex.Matches((string)MyFlexGrid[r, c], lookFor);
for (int i = matches.Count - 1; i >= 0; i--)
{
Match m = matches[i];
if (m != null && m.Groups.Count > 7 && m.Groups[7].ToString() == "ReferencedObject")
{
Regex regRefObj = new Regex(@"\#Link\:ReferencedObject\:([0-9]*) ([0-9a-zA-Z]*) ([0-9]*)", RegexOptions.Singleline);
Match myMatch = regRefObj.Match(m.Value);
if (myMatch.Success)
{
int usgid = int.Parse(myMatch.Groups[1].Value);
RtfRoUsageList.Add(usgid);
}
}
if (m != null && m.Groups.Count > 7 && m.Groups[7].ToString().StartsWith("Transition"))
{
Regex regRefObj = new Regex(@"\#Link\:Transition[a-zA-Z]*\:([0-9]*) ([0-9]*) ([0-9]*)", RegexOptions.Singleline);
Match myMatch = regRefObj.Match(m.Value);
if (myMatch.Success)
{
int tid = int.Parse(myMatch.Groups[2].Value);
RtfTransList.Add(tid);
int myIndex = m.Groups[4].Index;
int myLength = m.Groups[4].Length;
if (m.Groups[3].Value != " ")
{
myIndex = m.Groups[3].Index;
myLength += m.Groups[3].Length;
}
string gg = ((string)MyFlexGrid[r, c]).Substring(myIndex, myLength);
if (gg.ToUpper().Contains("(PAGE ~)")) RtfTransPageNumList.Add(tid); // B2020-089, check for upper case Page ~ in case step was upper cased
}
}
}
}
}
c = c + 1;
if (c == w)
{
c = 0;
r = r + 1;
}
}
}
else
{
// new roid is in flexgrid.roid. Compare to previous, if there was a previous. If there
// is a modify RO, then need to delete the existing rousage record because a new usage
// record will get created that contains the selected ROID.
Regex regRefObj = new Regex(@"\#Link\:ReferencedObject\:([0-9]*) ([0-9a-zA-Z]*) ([0-9]*)", RegexOptions.Singleline);
Match myMatch = regRefObj.Match(MyItemInfo.MyContent.Text);
if (myMatch.Success)
{
int usgid = int.Parse(myMatch.Groups[1].Value);
RoUsageInfo rui = RoUsageInfo.Get(usgid);
if (rui.ROID == MyFlexGrid.ROID)RtfRoUsageList.Add(usgid);
}
}
// compare ro usages & transitions from database and list from grid contents
// if in both lists, don't do anything
// if only in database list, delete usage.
// never will have condition where it is not in database list, but is in steprtb text list (this
// case is handled when ro is inserted.
if (MyItemInfo.MyContent.ContentRoUsages != null)
{
List<int> delRoUsgs = new List<int>();
foreach (RoUsageInfo ru in MyItemInfo.MyContent.ContentRoUsages)
if (!RtfRoUsageList.Contains(ru.ROUsageID)) delRoUsgs.Add(ru.ROUsageID);
foreach (int dRU in delRoUsgs) RoUsage.Delete(dRU);
}
if (MyItemInfo.MyContent.ContentTransitions != null)
{
List<int> delTrans = new List<int>();
foreach (TransitionInfo ti in MyItemInfo.MyContent.ContentTransitions)
{
if (!RtfTransList.Contains(ti.TransitionID)) delTrans.Add(ti.TransitionID);
else if (RtfTransPageNumList.Contains(ti.TransitionID))
{
using (Transition t = ti.Get())
{
t.Config = "<Config><Transition Formatted=\"True\" /></Config>";
t.Save();
}
}
}
foreach (int dt in delTrans) Transition.Delete(dt);
}
bool success = FinishSave(srchtxt);
if (success && !MyFlexGrid.IsRoTable)
{
MyStepRTB.FindAllLinks();
MyStepRTB.OrigRTF = MyStepRTB.Rtf;
MyStepRTB.ClearUndo();
}
}
private string DoLinkForRoTable(Item itm)
{
// if no ro has been defined yet, just return null
if (MyFlexGrid.ROID == null) return null;
ContentRoUsage rousg = null;
// using (Item itm = MyItemInfo.Get())
// {
using (RODb rodb = RODb.GetJustRoDb(MyFlexGrid.RODbId))
{
string padroid = (MyFlexGrid.ROID.Length <= 12) ? MyFlexGrid.ROID + "0000" : MyFlexGrid.ROID;
rousg = itm.MyContent.ContentRoUsages.Add(MyFlexGrid.ROID, rodb);
}
//itm.Save();
// }
MyItemInfo.MyContent.RefreshContentRoUsages();
return string.Format(@"#Link:ReferencedObject:{0} {1} {2}", rousg.ROUsageID, MyFlexGrid.ROID, MyFlexGrid.RODbId);
}
//private void ConvertTableToGrid(string valtext, int rodbid, string roid)
//{
// VE_Font vefont = MyItemInfo.GetItemFont();
// MyFlexGrid.Font = vefont.WindowsFont;
// //Initializing = true;
// MyFlexGrid.MergedRanges.Clear();
// MyFlexGrid.Clear();
// MyFlexGrid.ParseTableFromText(valtext);
// MyFlexGrid.AutoSizeCols();
// MyFlexGrid.AutoSizeRows();
// MyFlexGrid.MakeRTFcells();
// MyFlexGrid.RODbId = rodbid;
// MyFlexGrid.ROID = roid;
// MyFlexGrid.IsRoTable = true;
// //Initializing = false;
// SaveContents();
//}
private bool FinishSave(string searchableText)
{
// Just in case if the grid was in a mode to change sizes, clear out that setting
// in the grid:
MyFlexGrid.Cols.Fixed = 0;
MyFlexGrid.Rows.Fixed = 0;
MyFlexGrid.ShowTableCellShading(); // C2021-004 if the grid was in Fixed Mode, then also re-show the table cell shading
string xml = MyFlexGrid.GetXMLData();
using (Item itm = MyItemInfo.Get())
{
//if (!MatchingXML(itm.MyContent.MyGrid.Data, xml))
//{
// CompareXML(itm.MyContent.MyGrid.Data, xml);
itm.MyContent.MyGrid.Data = xml;
itm.MyContent.MyGrid.DTS = DateTime.Now;
itm.MyContent.MyGrid.UserID = Volian.Base.Library.VlnSettings.UserID;
//}
// if this is the initial save of an ro table, then the 'DoLinkForRoTable' will
// create the usage for it. this code gets run on modify of the ro table and also
// on exit of the griditem. We don't want to save the ro usage again, if it's already
// been saved.
if (MyFlexGrid.IsRoTable && MyFlexGrid.ROID != null && itm.MyContent.ContentRoUsageCount < 1)
{
searchableText = string.Format(@"\v<START]\v0 {0} \v {1}[END>\v0 ", searchableText, DoLinkForRoTable(itm));
//if (itm.MyContent.Text != searchableText)
//{
itm.MyContent.Text = searchableText;
itm.MyContent.UserID = Volian.Base.Library.VlnSettings.UserID;
itm.MyContent.DTS = DateTime.Now;
//}
}
else
{
itm.MyContent.Text = searchableText;
itm.MyContent.UserID = Volian.Base.Library.VlnSettings.UserID;
itm.MyContent.DTS = DateTime.Now;
}
if (!MyFlexGrid.IsRoTable) itm.MyContent.Text = searchableText;
// if the plant has the change id option, the change id was entered when the program started.
// this should be saved for every piece of edited data. Note that the set of config
// item Step_MultipleChangeID has the save built in to it.
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds &&
!this.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.EditorialChange)
{
StepConfig sc = itm.MyConfig as StepConfig;
if (sc == null)
sc = new StepConfig();
sc.Step_ChangeID = this.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.ChgId;
if (itm.MyConfig == null) itm.MyContent.Config = sc.ToString();
}
itm.Save();
StepConfig myItmCfg =MyItemInfo.MyConfig as StepConfig;
// We saved changes made to some step text. Reset the change bar override.
// IF there is a step config remove the change bar override by setting the CBOverride value to null
// This fixes a problem reported by Farly where if the change bar or overridden to be off, the next
// time a change was made, the change bar remained turned off.
if (myItmCfg != null)
myItmCfg.Step_CBOverride = null; // clear the change bar override
MyItemInfo.MyContent.MyGrid.ResetContent(itm.MyContent.MyGrid);
}
return true;
}
private void CompareXML(string v1, string v2)
{
v1 = Regex.Replace(v1, "\r\n *", "");
v1 = Regex.Replace(v1, "version *= *\"[^\"]*\"", "");
v2 = Regex.Replace(v2, "\r\n *", "");
v2 = Regex.Replace(v2, "version *= *\"[^\"]*\"", "");
int iStart = 0;
int l1 = v1.Length;
int l2 = v2.Length;
int l3 = Math.Min(l1, l2);
while (iStart < l3 && v1[iStart] == v2[iStart])
iStart++;
int iEnd1 = l1 - 1;
int iEnd2 = l2 - 1;
while (iStart < iEnd1 && iStart < iEnd2 && v1[iEnd1] == v2[iEnd2])
{
iEnd1--;
iEnd2--;
}
if (iStart < iEnd1) Console.WriteLine("v1 = {0}", v1.Substring(iStart, iEnd1 - iStart));
if (iStart < iEnd2) Console.WriteLine("v2 = {0}", v2.Substring(iStart, iEnd2 - iStart));
}
private bool MatchingXML(string v1, string v2)
{
v1 = Regex.Replace(v1, "\r\n *", "");
v1 = Regex.Replace(v1, "version *= *\"[^\"]*\"", "");
v2 = Regex.Replace(v2, "\r\n *", "");
v2 = Regex.Replace(v2, "version *= *\"[^\"]*\"", "");
int l1 = v1.Length;
int l2 = v2.Length;
if(l1 != l2 )return false;
//int l3 = Math.Min(l1, l2);
//int l4 = Math.Max(l1, l2);
for (int i = 0; i < l1; i++)
if (v1[i] != v2[i]) return false;
return true;
//Console.WriteLine("{0} - {1},{2}",i, showChar(v1[i]), showChar(v2[i]));
//if(l1 > l3)Console.WriteLine("v1 = {0}",v1.Substring(l3));
//if(l2 > l3)Console.WriteLine("v2 = {0}",v2.Substring(l3));
}
//private object showChar(char c)
//{
// int i = (int)c;
// if (i <= 32)
// return string.Format("<{0}>", i);
// else
// return c.ToString();
//}
public void BasicSave()
{
using (Item itm = MyItemInfo.Get())
{
itm.MyContent.MyGrid.Data = MyFlexGrid.GetXMLData();
itm.Save();
//MyItemInfo.MyContent.MyGrid.ResetContent(itm.MyContent.MyGrid);
}
}
public override bool CanExpand { get { return false; } set { ;} }
public override void HandleResize() { ;} // DONE
public override void MatchExpanded() { ;} // DONE
public override void ItemSelect()
{
// Was getting an Error that _MyStepRTB was Disposed RHM 20101217
if (!MyFlexGrid.Disposing)
{
Focus();
MyFlexGrid.Focus();
if (!MyFlexGrid.IsRoTable) // Table ROs are not editable - don't select a table cell
{
try
{
MyFlexGrid.Select(0, 0);
MyFlexGrid.FirstEntry = true; // to fix a problem with initial mouse click into table
}
catch (Exception ex)
{
FlexibleMessageBox.Show("The content of this table is corrupted. You will either need to restore a previous version or delete it.", "Table Corrupted", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
else
{
_MyLog.WarnFormat("Attempt to give Focus to Disposed Object {0}", MyID);
}
//ScrollToCenter();
}
public override void ItemShow()
{
MyFlexGrid.Focus();
//ScrollToCenter();
}
public StepRTB DisplayRoStepRTB;
public override StepRTB MyStepRTB
{
get
{
return MyFlexGrid.TableCellEditor;
}
}
public override DialogResult ReplaceText(string rpltxt, string fndstr, bool caseSensitive, bool matchWholeWord, bool reverse, bool prompt, IWin32Window fndrpldlg)
{
int r = MyFlexGrid.Row;
int c = MyFlexGrid.Col;
if (!reverse)
{
int w = MyFlexGrid.Cols.Count;
int h = MyFlexGrid.Rows.Count;
while (r < h)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
int ss = MyStepRTB.SelectionStart;
int sl = MyStepRTB.SelectionLength;
MyFlexGrid.StartEditing();
MyStepRTB.Select(ss, sl); // need to reset selection because startediting positions to end.
if (MyStepRTB.ReadOnly)
{
FlexibleMessageBox.Show("Cannot replace linked text!", "Find/Replace", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
return DialogResult.Yes;
}
string oldRtf = MyStepRTB.Rtf;
DialogResult dr = MyStepRTB.ReplaceText(rpltxt, fndstr, caseSensitive, matchWholeWord, reverse, prompt, fndrpldlg);
if (oldRtf != MyStepRTB.Rtf) MyFlexGrid[r, c] = MyStepRTB.Rtf;
if (dr == DialogResult.Yes || dr == DialogResult.Cancel) return dr;
}
c = c + 1;
if (c == w)
{
c = 0;
r = r + 1;
}
if (r < h)
{
MyFlexGrid.Select(r, c);
MyStepRTB.Select(0, 0);
}
}
}
else // reverse
{
while (r >= 0)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
int ss = MyStepRTB.SelectionStart;
int sl = MyStepRTB.SelectionLength;
MyFlexGrid.StartEditing();
MyStepRTB.Select(ss, sl);
if (MyStepRTB.ReadOnly)
{
FlexibleMessageBox.Show("Cannot replace linked text!", "Find/Replace", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
return DialogResult.Yes;
}
string oldRtf = MyStepRTB.Rtf;
DialogResult dr = MyStepRTB.ReplaceText(rpltxt, fndstr, caseSensitive, matchWholeWord, reverse, prompt, fndrpldlg);
if (oldRtf != MyStepRTB.Rtf) MyFlexGrid[r, c] = MyStepRTB.Rtf;
if (dr == DialogResult.Yes || dr == DialogResult.Cancel) return dr;
}
c = c - 1;
if (c < 0)
{
c = MyFlexGrid.Cols.Count - 1;
r = r - 1;
}
cr = MyFlexGrid.GetMergedRange(r, c);
if (r >= 0 && cr.r1 == r && cr.c1 == c)
{
MyFlexGrid.Select(r, c);
MyFlexGrid.StartEditing();
MyStepRTB.Select(MyStepRTB.Text.Length, 0);
}
}
}
return DialogResult.No;
}
public override bool FindText(string str, bool caseSensitive, bool matchWholeWord, bool reverse)
{
if (MyFlexGrid.Row < 0) MyFlexGrid.Row = (reverse) ? MyFlexGrid.Rows.Count - 1 : 0;
if (MyFlexGrid.Col < 0) MyFlexGrid.Col = (reverse) ? MyFlexGrid.Cols.Count - 1 : 0;
int r = MyFlexGrid.Row;
int c = MyFlexGrid.Col;
if (!reverse)
{
int w = MyFlexGrid.Cols.Count;
int h = MyFlexGrid.Rows.Count;
while (r < h)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
int ss = MyStepRTB.SelectionStart + MyStepRTB.SelectionLength;
MyFlexGrid.StartEditing();
MyStepRTB.Select(ss, 0); // need to reset selection because startediting positions to end.
bool scn = MyStepRTB.FindText(str, caseSensitive, matchWholeWord, reverse);
if (scn) return true;
}
c = c + 1;
if (c == w)
{
c = 0;
r = r + 1;
}
if (r < h)
{
MyFlexGrid.Select(r, c);
MyStepRTB.Select(0, 0);
}
}
}
else
{
while (r >= 0)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
int ss = MyStepRTB.SelectionStart;
MyFlexGrid.StartEditing();
MyStepRTB.Select(ss, 0);
bool scn = MyStepRTB.FindText(str, caseSensitive, matchWholeWord, reverse);
if (scn) return true;
}
c = c - 1;
if (c < 0)
{
c = MyFlexGrid.Cols.Count - 1;
r = r - 1;
}
cr = MyFlexGrid.GetMergedRange(r, c);
if (r >= 0 && cr.r1 == r && cr.c1 == c)
{
MyFlexGrid.Select(r, c);
MyFlexGrid.StartEditing();
MyStepRTB.Select(MyStepRTB.Text.Length, 0);
}
}
}
return false;
}
public override void PositionToEnd()
{
int r = MyFlexGrid.Rows.Count - 1;
int c = MyFlexGrid.Cols.Count - 1;
MyFlexGrid.Select(r, c);
while (r >= 0)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
MyFlexGrid.StartEditing();
return;
}
c = c - 1;
if (c < 0)
{
c = MyFlexGrid.Cols.Count - 1;
r = r - 1;
}
if (r >= 0)
{
MyFlexGrid.Select(r, c);
MyStepRTB.Select(MyStepRTB.Text.Length, 0);
}
}
}
public override void PositionToStart()
{
MyFlexGrid.Select(0,0);
MyFlexGrid.StartEditing();
MyStepRTB.Select(0, 0);
}
public override string SelectedTextForFind
{
get
{
StepRTB srtb = MyStepRTB;
if (srtb.SelectionLength > 0)
{
if (srtb.IsSelectionLinked(srtb.SelectionStart, srtb.SelectionLength))
return srtb.SelectedText.Substring(0, srtb.SelectedText.IndexOf("#Link"));
else
return srtb.SelectedText;
}
return null;
}
}
public override bool SpellCheckNext()
{
if (MyFlexGrid.IsRoTable) return true; // skip RO Tables
int r = MyFlexGrid.Row;
int c = MyFlexGrid.Col;
int w = MyFlexGrid.Cols.Count;
int h = MyFlexGrid.Rows.Count;
while (r < h)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
MyFlexGrid.Select(r, c);
MyFlexGrid.StartEditing();
string oldRtf = MyStepRTB.Rtf;
bool scn = MyStepRTB.SpellCheckNext();
if (oldRtf != MyStepRTB.Rtf) MyFlexGrid[r, c] = MyStepRTB.Rtf;
if (!scn) return false;
}
c = c + 1;
if (c == w)
{
c = 0;
r = r + 1;
}
}
return true;
}
public override void IdentifyMe(bool highlight)
{
if (highlight)
{
MyFlexGrid.StyleBackColor = Color.Gray;
MyFlexGrid.Styles.Fixed.BackColor = Color.Gray;
}
else
{
MyFlexGrid.Styles.Fixed.BackColor = MyFlexGrid.DefaultFixedBackgroundColor;
MyFlexGrid.StyleBackColor = MyFlexGrid.DefaultCellBackgroundcolor;
if (MyFlexGrid.Focused) // If active Set BackColor to the active color
SetActive();
else // Otherwise Set the BackColor to either the InactiveColor or the AnnotationColor
{
MyFlexGrid.StyleBackColor =
MyItemInfo.ItemAnnotationCount == 0 ? MyStepPanel.InactiveColor : MyStepPanel.AnnotationColor;
// Turn-off Size adjustment
MyFlexGrid.Cols.Fixed = 0;
MyFlexGrid.Rows.Fixed = 0;
}
// C2021-004 Table Cell Shading.
// If the table has annotations, then show the yellow annoation background (table is not active control when in here)
// otherwise show the table shading assigned by the user
if (MyFlexGrid.GetMyItemInfo().ItemAnnotationCount == 0)
MyFlexGrid.ShowTableCellShading();
}
}
public override void SetActive()
{
AdjustColorsForEditMode();
}
private bool _Empty = false;
public override bool Empty
{
get { return _Empty; }
set { _Empty = value; }
}
private bool _Initializing = false;
public bool Initializing
{
get { return _Initializing; }
set { _Initializing = value; }
}
private bool _ActiveMode = false;
public override void RefreshDisplay(bool activeMode)
{
_ActiveMode = activeMode;
//XmlDocument xd = new XmlDocument();
//xd.LoadXml(MyItemInfo.MyContent.MyGrid.Data);
//using (StringReader sr = new StringReader())
Initializing = true;
MyFlexGrid.LoadGrid(MyItemInfo);
Initializing = false;
MyFlexGrid.KeyActionTab = KeyActionEnum.MoveAcross;
MyFlexGrid.AdjustGridControlSize();
// When a grid is read from XML, all of the styles are updated to the values in the XML.
// Thus any specific settings need to be set after the grid is read.
MyFlexGrid.Styles["Highlight"].BackColor = Color.LightCyan;
MyFlexGrid.Styles["Focus"].BackColor = Color.LightCyan;
MyFlexGrid.HighLight = activeMode ? C1.Win.C1FlexGrid.HighLightEnum.Always : C1.Win.C1FlexGrid.HighLightEnum.WithFocus;
MyFlexGrid.VwMode = MyStepPanel.VwMode;
}
public override void ToggleEditView(E_ViewMode vwMode)
{
/*
* TODO:
* 1) SaveContents
*/
RefreshDisplay(false);
MyFlexGrid.VwMode = vwMode;
}
public override int TabLeft { get { return lblTab.Left; } set { lblTab.Left = value; } }
public override Font TabFont { get { return lblTab.Font; } set { lblTab.Font = value; } }
public override string TabText { get { return lblTab.Text; } }
public override Point TabLocation { get { return lblTab.Location; } }
public override Font ContentFont { get { return MyFlexGrid.Font; } set { MyFlexGrid.Font = value; } } // TODO how do we know what font tables are in?
public override float ContentTop { get { return MyFlexGrid.Top; } }
public override void SetupHeader(ItemInfo itemInfo) { ;} // tables do not have headers
public override void ShowExpanded() {;}
public override void SetText()
{
// if this is an RO Table, regenerate xml. This is done in the case that
// the rotable was updated by the ro editor.
//if (MyFlexGrid.IsRoTable) RefreshGridData();
RefreshDisplay(false);
IdentifyMe(false);
}
//private void RefreshGridData()
//{
// string ROID = MyFlexGrid.ROID;
// int rodbid = MyFlexGrid.RODbId;
// //MyFlexGrid.Clear();
// ROFSTLookup MyROFSTLookup = MyItemInfo.MyDocVersion.DocVersionAssociations[0].MyROFst.ROFSTLookup;
// MyFlexGrid.ConvertTableROToGrid(MyROFSTLookup.GetRoValue(ROID), rodbid, ROID);
// //ConvertTableToGrid(MyROFSTLookup.GetRoValue(ROID), rodbid, ROID);
// //MyFlexGrid.RODbId = rodbid;
// //MyFlexGrid.ROID = ROID;
// //MyFlexGrid.IsRoTable = true;
// //SaveContents();
//}
public override void SetExpandAndExpander(ItemInfo itemInfo) { CanExpand = false; } // can't expand a table
public void SavePastedCellRoTran()
{
if (!MyFlexGrid.GetXMLData().Contains("&lt;NewID&gt;")) return;
BasicSave();
// need to loop thru all pasted cells: for now do all cells.
int w = MyFlexGrid.Cols.Count;
int h = MyFlexGrid.Rows.Count;
int r = 0;
int c = 0;
String Rtf = null;
while (r < h)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
Rtf = (string)MyFlexGrid[r, c];
if (Rtf != null)
{
int startIndx = 0;
while (Rtf.IndexOf("<NewID>") > -1)
{
// first find the new link and determine whether it's RO or transition.
int indx = Rtf.IndexOf(@"#Link:ReferencedObject:<NewID>", startIndx);
if (indx > 0)
{
// only look in the substring limited by the first occurrance of [END>. If there is more
// than one, don't get multiple links in the string.
int endindx = Rtf.IndexOf(@"END>", indx) + 4;
Match mro = Regex.Match(Rtf.Substring(indx, endindx - indx), @"([A-Za-z]*):(.*)\[END>");
string linkstr = mro.Groups[2].Value;
string[] roparts = linkstr.Split(" ".ToCharArray());
ContentRoUsage rousg = null;
int oldid = -1;
using (Item itm = MyItemInfo.Get())
{
using (RODb rodb = RODb.GetJustRoDb(Convert.ToInt32(roparts[2])))
{
rousg = itm.MyContent.ContentRoUsages.Add(roparts[1], rodb);
}
oldid = rousg.ROUsageID;
int newid = Rtf.IndexOf("<NewID>", indx);
Rtf = Rtf.Remove(newid, 7);
Rtf = Rtf.Insert(newid, string.Format("<CROUSGID={0}>", rousg.ROUsageID));
itm.Save(); // this will generate a new ROUsageID that we grab and put in the RO link in the RTF
Rtf = Rtf.Replace(string.Format("<CROUSGID={0}>", oldid), rousg.ROUsageID.ToString());
itm.Save();
MyItemInfo.MyContent.RefreshContentRoUsages();
}
startIndx = endindx;
}
else
{
Match mt = Regex.Match(Rtf, @"#Link:Transition:([0-9]+) <NewID> ");
if (mt.Length <= 0) mt = Regex.Match(Rtf, @"#Link:TransitionRange:([0-9]+) <NewID> ");
if (mt.Length > 0)
{
int endtindx = Rtf.IndexOf("END>", mt.Index) + 4;
indx = mt.Index + 6; // get past '#Link:"
Match m = Regex.Match(Rtf.Substring(indx, endtindx - indx), @"([A-Za-z]*):(.*)\[END>");
bool isSingleTran = true;
if (Rtf.Substring(indx, 16).IndexOf("TransitionRange") >= 0) isSingleTran = false;
string linkstr = m.Groups[2].Value;
string[] tparts = linkstr.Split(" ".ToCharArray());
int type = System.Convert.ToInt32(tparts[0]);
int tr1 = System.Convert.ToInt32(tparts[2]); // tparts[2] is token for tranid
int tr2 = tr1;
if (tparts.Length > 3)
tr2 = System.Convert.ToInt32(tparts[3]); // tparts[3] is token for rangeid
bool dispose1 = false;
Item itm1 = null;
bool dispose2 = false;
Item itm2 = null;
using (Item itm = MyItemInfo.Get())
{
if (itm.ItemID == tr1)
itm1 = itm; // a transition that points to itself should not dispose
else
{
dispose1 = true;
itm1 = Item.Get(tr1);
}
if (itm.ItemID == tr2)
itm2 = itm; // a transition that points to itself should not dispose
else if (tr1 == tr2)
itm2 = itm1; // if both destinations are the same only dispose the first one
else
{
dispose2 = true;
itm2 = Item.Get(tr2);
}
ContentTransition ct = itm.MyContent.ContentTransitions.Add(itm1, itm2);
//Console.WriteLine("CT {0},{1},{2},{3}", ct.TransitionID, itm.ItemID, itm.MyContent.MyContentUnique, itm.MyContent.ContentTransitions.Count);
ct.TranType = type;
if (isSingleTran)
ct.IsRange = 0;
else if (tr1 != tr2)
ct.IsRange = 1;
else
ct.IsRange = 2;
int oldidt = ct.TransitionID;
int newidt = Rtf.IndexOf("<NewID>", indx);
Rtf = Rtf.Remove(newidt, 7);
Rtf = Rtf.Insert(newidt, string.Format("<CTID={0}>", ct.TransitionID));
itm.Save(); // this will generate a new TransitionID that we grab and put in the Transition link in the RTF
Rtf = Rtf.Replace(string.Format("<CTID={0}>", oldidt), ct.TransitionID.ToString());
itm.Save();
MyItemInfo.MyContent.RefreshContentTransitions();
}
if (dispose2) itm2.Dispose();
if (dispose1) itm1.Dispose();
}
}
}
MyFlexGrid[r, c] = Rtf;
// B2022-046 need to save context of each cell in the table after fixing RO and Transition links
// otherwise the RTF for that cell will revert back to previous data then the itm.Save() is called above
SaveContents();
}
}
c = c + 1;
if (c == w)
{
c = 0;
r = r + 1;
}
}
}
public override void SaveCurrentAndContents()
{
IsSaving = true;
if (MyFlexGrid.Row >= 0 && MyFlexGrid.Col >= 0 && MyStepRTB.EditMode) // Only if a Cell is Selected
{
CellRange cr = MyFlexGrid.GetMergedRange(MyFlexGrid.Selection.r1, MyFlexGrid.Selection.c1); // B2018-127 get merged range
int row = MyFlexGrid.Row;
int col = MyFlexGrid.Col;
//SaveContents();
DoNotRefresh = true;
MyStepRTB.Rtf = MyStepRTB.DoNewLinkInGridCell();
DoNotRefresh = false;
MyFlexGrid.Row = row;
MyFlexGrid.Col = col;
MyFlexGrid[cr.r1, cr.c1] = MyStepRTB.Rtf; // B2018-127 this saves to the first cell in a merged range
}
if (!MyFlexGrid.IsDirty) return;
SaveContents();
IsSaving = false;
}
#endregion
#region Miscellaneous Support
internal void SetSearchCell(string SearchString)
{
// Walk thru grid to find first occurance of SearchString and set that cell for
// edit.
int r = 0;
int c = 0;
int w = MyFlexGrid.Cols.Count;
int h = MyFlexGrid.Rows.Count;
while (r < h)
{
CellRange cr = MyFlexGrid.GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
if (MyFlexGrid[r, c] != null)
{
MyFlexGrid.StartEditing(r, c);
TableCellEditor tce = MyFlexGrid.TableCellEditor;
// note that this method is only used from Search Results.
// The search query will handle the case sensitivity, so
// we can just see if contains the string without considering
// case sensitivity.
if (tce.Text.ToUpper().Contains(SearchString.ToUpper()))
return;
}
}
c = c + 1;
if (c == w)
{
c = 0;
r = r + 1;
}
}
}
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink