Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
2ca433c83f01b9feb21bcd090dc75218da7e3cc1
SourceCode/PROMS/Volian.Controls.Library/VlnFlexGrid.cs.bak

4927 lines
156 KiB
C#
Raw Blame History

using System;
using System.ComponentModel;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Xml;
using System.IO;
using Volian.Controls.Library;
using VEPROMS.CSLA.Library;
using C1.Win.C1FlexGrid;
using C1.Win.C1SpellChecker;
using System.Text.RegularExpressions;
using System.Xml.Serialization;
namespace Volian.Controls.Library
{
public delegate void VlnFlexGridEvent(object sender, EventArgs args);
public delegate void VlnFlexGridCursorMovementEvent(object sender, VlnFlexGridCursorMovementEventArgs args);
public delegate string VlnFlexGridPasteEvent(object sender, VlnFlexGridPasteEventArgs args);
public delegate void VlnFlexGridkeyEvent(object sender, KeyEventArgs args);
public partial class vlnPanel : Panel
{
private int _Opacity = 128;
//public int Opacity
//{
// get { return _Opacity; }
// set { _Opacity = value; }
//}
public vlnPanel()
{
InitializeComponent();
}
public vlnPanel(IContainer container)
{
container.Add(this);
InitializeComponent();
}
//protected override CreateParams CreateParams
//{
// get
// {
// CreateParams prams = base.CreateParams;
// prams.ExStyle |= 0x020; // transparent
// return prams;
// }
//}
//protected override void OnPaint(PaintEventArgs pe)
//{
// pe.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(_Opacity, this.BackColor)), this.ClientRectangle);
//}
}
public partial class VlnFlexGrid : C1.Win.C1FlexGrid.C1FlexGrid
{
private bool _Disposed = false;
private static int _CountCreated = 0;
private static int _CountDisposed = 0;
private static int _CountFinalized = 0;
private static int IncrementCountCreated
{ get { return ++_CountCreated; } }
private int _CountWhenCreated = IncrementCountCreated;
public static int CountCreated
{ get { return _CountCreated; } }
public static int CountNotDisposed
{ get { return _CountCreated - _CountDisposed; } }
public static int CountNotFinalized
{ get { return _CountCreated - _CountFinalized; } }
private bool _Finalized = false;
~VlnFlexGrid()
{
if(!_Finalized) _CountFinalized++;
_Finalized = true;
}
private C1SpellChecker _SpellChecker;
public C1SpellChecker SpellChecker
{
get { return _SpellChecker; }
set { _SpellChecker = value; }
}
//public string GridStackTrace
//{
// get
// {
// string st = Volian.Base.Library.vlnStackTrace.GetStack();
// st = StripFunnyCharacters(st);
// return st;
// Console.WriteLine(st);
// return st.Replace(@"\","|");
// }
// set
// {
// ;
// }
//}
//private string StripFunnyCharacters(string st)
//{
// StringBuilder sb = new StringBuilder();
// foreach (char c in st)
// {
// if ((c < ' ' || c > 255) && !"\r\n\t".Contains(c.ToString()))
// sb.Append(string.Format("x{0:X4}", (int)c));
// else
// sb.Append(c);
// }
// return sb.ToString();
//}
public bool IsDirty
{
get
{
return IsGridChanged(this._MyItemInfo.MyContent.MyGrid.Data, this.GetXMLData());
}
}
private bool IsGridChanged(string oldXml, string newXml)
{
if (this.TableCellEditor.Text.Contains("<NewID>"))
return false;
XmlDocument XdOld = new XmlDocument();
XdOld.LoadXml(oldXml);
XmlDocument XdNew = new XmlDocument();
XdNew.LoadXml(newXml);
//check volian borders 1st
if (XdNew.SelectSingleNode("C1FlexGrid/Control/MyBorderDetailString").InnerText != XdOld.SelectSingleNode("C1FlexGrid/Control/MyBorderDetailString").InnerText)
return true;
//check row/col sizes 2nd
if (GetRowColSizeString(XdNew) != GetRowColSizeString(XdOld))
return true;
//check for cell data changes 3rd
if (GetCellDataString(XdNew) != GetCellDataString(XdOld))
return true;
//check for cell format changes 4th
if (GetCellFormatString(XdNew) != GetCellFormatString(XdOld))
return true;
//check for merged cells 5th
if (GetCellMergeString(XdNew) != GetCellMergeString(XdOld))
return true;
return false;
}
private string GetRowColSizeString(XmlDocument xd)
{
string defCW = xd.SelectSingleNode("C1FlexGrid/ColumnInfo/DefaultSize").InnerText;
string defRH = xd.SelectSingleNode("C1FlexGrid/RowInfo/DefaultSize").InnerText;
int cols = int.Parse(xd.SelectSingleNode("C1FlexGrid/ColumnInfo/Count").InnerText);
int rows = int.Parse(xd.SelectSingleNode("C1FlexGrid/RowInfo/Count").InnerText);
List<string> rh = new List<string>();
for (int i = 0; i < rows; i++)
rh.Add(defRH);
List<string> cw = new List<string>();
for (int i = 0; i < cols; i++)
cw.Add(defCW);
XmlNodeList nlr = xd.SelectNodes("C1FlexGrid/Rows/Row");
foreach (XmlNode nr in nlr)
{
int idx = int.Parse(nr.Attributes.GetNamedItem("index").InnerText);
rh[idx] = nr.SelectSingleNode("Height").InnerText;
}
XmlNodeList nlc = xd.SelectNodes("C1FlexGrid/Columns/Column");
foreach (XmlNode nc in nlc)
{
int idx = int.Parse(nc.Attributes.GetNamedItem("index").InnerText);
cw[idx] = nc.SelectSingleNode("Width").InnerText;
}
string rhcw = "RowHeights: ";
string sep = string.Empty;
foreach (string s in rh)
{
rhcw += sep + s;
sep = ",";
}
rhcw += " - ColWidths: ";
sep = string.Empty;
foreach (string s in cw)
{
rhcw += sep + s;
sep = ",";
}
return rhcw;
}
private string GetCellDataString(XmlDocument xd)
{
int cols = int.Parse(xd.SelectSingleNode("C1FlexGrid/ColumnInfo/Count").InnerText);
int rows = int.Parse(xd.SelectSingleNode("C1FlexGrid/RowInfo/Count").InnerText);
List<string> datum = new List<string>();
for (int i = 0; i < rows * cols; i++)
datum.Add("|");
XmlNodeList nl = xd.SelectNodes("C1FlexGrid/Cells/Cell/Data");
string data = string.Empty;
foreach (XmlNode xn in nl)
{
RichTextBox rtb = new RichTextBox();
rtb.Rtf = xn.InnerText;
XmlAttribute xa = xn.ParentNode.Attributes.GetNamedItem("index") as XmlAttribute;
string[] rc = xa.InnerText.Split(',');
int r = int.Parse(rc[0]);
int c = int.Parse(rc[1]);
int index = r * cols + c;
datum[index] = "|" + (rtb.Text == "" ? "" : rtb.Text);
}
foreach (string s in datum)
data += s;
return data;
}
private string GetCellFormatString(XmlDocument xd)
{
int cols = int.Parse(xd.SelectSingleNode("C1FlexGrid/ColumnInfo/Count").InnerText);
int rows = int.Parse(xd.SelectSingleNode("C1FlexGrid/RowInfo/Count").InnerText);
List<string> datum = new List<string>();
for (int i = 0; i < rows * cols; i++)
datum.Add("|");
XmlNodeList nl = xd.SelectNodes("C1FlexGrid/Cells/Cell/Data");
string data = string.Empty;
foreach (XmlNode xn in nl)
{
RichTextBox rtb = new RichTextBox();
rtb.Rtf = xn.InnerText;
XmlAttribute xa = xn.ParentNode.Attributes.GetNamedItem("index") as XmlAttribute;
string[] rc = xa.InnerText.Split(',');
int r = int.Parse(rc[0]);
int c = int.Parse(rc[1]);
int index = r * cols + c;
datum[index] = "|" + (rtb.Text == "" ? "" : rtb.Rtf);
}
foreach (string s in datum)
data += s;
return data;
}
private string GetCellMergeString(XmlDocument xd)
{
if(xd.SelectSingleNode("C1FlexGrid/MergedRanges") == null)
return string.Empty;
return xd.SelectSingleNode("C1FlexGrid/MergedRanges").InnerXml;
}
private static GridCopyInfo _MyCopyInfo;
public static GridCopyInfo MyCopyInfo
{
get
{
if (_MyCopyInfo == null)
_MyCopyInfo = new GridCopyInfo();
return _MyCopyInfo;
}
}
private Color _DefaultCellBackgroundcolor;
public Color DefaultCellBackgroundcolor
{
get { return _DefaultCellBackgroundcolor; }
}
private Color _DefaultFixedBackgroundColor;
public Color DefaultFixedBackgroundColor
{
get { return _DefaultFixedBackgroundColor; }
}
public void CopyToCopiedFlexGrid(GridCopyOption myCopyOption)
{
MyCopyInfo.MyCopiedFlexGrid = new VlnFlexGrid(); //make a copy of the grid being copied
using (StringReader sr = new StringReader(this.GetXMLData()))
{
MyCopyInfo.MyCopiedFlexGrid.ReadXml(sr);
this.BorderStyle = C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.None;
sr.Close();
}
MyCopyInfo.MyCopyOption = myCopyOption;
OnCopyOptionChanged(this, new EventArgs());
switch (MyCopyInfo.MyCopyOption)
{
case GridCopyOption.Row:
MyCopyInfo.MyCopiedCellRange = MyCopyInfo.MyCopiedFlexGrid.GetCellRange(Selection.r1, 0, Selection.r2, Cols.Count - 1);
break;
case GridCopyOption.Column:
MyCopyInfo.MyCopiedCellRange = MyCopyInfo.MyCopiedFlexGrid.GetCellRange(0, Selection.c1, Rows.Count - 1, Selection.c2);
break;
case GridCopyOption.Selection:
MyCopyInfo.MyCopiedCellRange = MyCopyInfo.MyCopiedFlexGrid.GetCellRange(Selection.r1, Selection.c1, Selection.r2, Selection.c2);
break;
default:
break;
}
}
public event VlnFlexGridEvent CopyOptionChanged;
public void OnCopyOptionChanged(object sender, EventArgs args)
{
if (CopyOptionChanged != null) CopyOptionChanged(sender, args);
}
[XmlElement("MyBorders")]
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public string MyBorderDetailString
{
get
{
return MyBorders.ConvertToString();
}
set
{
if (value != null)
_MyBorders = VlnBorders.Get(value);
else
_MyBorders = null;
}
}
private VlnBorders _MyBorders;
[XmlIgnore]
public VlnBorders MyBorders
{
get
{
if (_MyBorders == null)
_MyBorders = new VlnBorders(GridLinePattern.Single, Rows.Count, Cols.Count);
return _MyBorders;
}
set { _MyBorders = value; }
}
private ItemInfo _MyItemInfo;
public ItemInfo GetMyItemInfo()
{
return _MyItemInfo;
}
//public ItemInfo MyItemInfo
//{
// get { return _MyItemInfo; }
// set { _MyItemInfo = value; }
//}
public bool TopRowHasBorder()
{
for (int c = 0; c < Cols.Count - 1; c++)
if (MyBorders.HorizontalLines[0, c] != GridLinePattern.None) return true;
return false;
}
public void SetBorders(CellRange myRange,
GridLinePattern top, GridLinePattern middle, GridLinePattern bottom,
GridLinePattern left, GridLinePattern center, GridLinePattern right)
{
for (int r = myRange.r1; r <= myRange.r2; r++)
for (int c = myRange.c1; c <= myRange.c2; c++)
{
CellRange cr = GetMergedRange(r, c);
if (r == myRange.r1) // Top Border
if(top != GridLinePattern.Mixed) MyBorders.HorizontalLines[cr.r1, cr.c1]=top;
if (c == myRange.c1) // Left Border
if(left != GridLinePattern.Mixed) MyBorders.VerticalLines[cr.r1, cr.c1]=left;
if (r == myRange.r2) // Bottom Border
if(bottom != GridLinePattern.Mixed) MyBorders.HorizontalLines[cr.r2 + 1, cr.c2]=bottom;
if (c == myRange.c2) // Right Border
if(right != GridLinePattern.Mixed) MyBorders.VerticalLines[cr.r2, cr.c2 + 1] = right;
if (r == cr.r1 && c == cr.c1) // Look for inside lines
{
if (cr.r1 > myRange.r1 && cr.r1 <= myRange.r2) // Inside Horizontal Top
if (middle != GridLinePattern.Mixed)
{
MyBorders.HorizontalLines[cr.r1, cr.c1] = middle;
MyBorders.HorizontalLines[cr.r1, cr.c2] = middle;
}
if (cr.r2 > myRange.r1 && cr.r2 < myRange.r2) // Inside Horizontal Bottom
if(middle != GridLinePattern.Mixed) MyBorders.HorizontalLines[cr.r2 + 1, cr.c2]=middle;
if (cr.c1 > myRange.c1 && cr.c1 <= myRange.c2) // Inside Vertical Left
if (center != GridLinePattern.Mixed)
{
MyBorders.VerticalLines[cr.r1, cr.c1] = center;
MyBorders.VerticalLines[cr.r2, cr.c1] = center;
}
if (cr.c2 > myRange.c1 && cr.c2 < myRange.c2) // Inside Vertical Right
if(center != GridLinePattern.Mixed) MyBorders.VerticalLines[cr.r2, cr.c2 + 1]=center;
}
c = cr.c2;//Skip to the end of the merged cells
}
}
public void PasteBorders(int r, int c, int br, int bc)
{
MyBorders.HorizontalLines[r, c] = MyCopyInfo.MyCopiedFlexGrid.MyBorders.HorizontalLines[br,bc];
MyBorders.VerticalLines[r, c] = MyCopyInfo.MyCopiedFlexGrid.MyBorders.VerticalLines[br, bc];
MyBorders.HorizontalLines[r+1, c] = MyCopyInfo.MyCopiedFlexGrid.MyBorders.HorizontalLines[br+1, bc];
MyBorders.VerticalLines[r, c+1] = MyCopyInfo.MyCopiedFlexGrid.MyBorders.VerticalLines[br, bc+1];
}
[XmlIgnore]
public bool HasVScroll
{
get
{
return RTBAPI.HasVertScroll(this);
}
}
[XmlIgnore]
public bool HasHScroll
{
get
{
return RTBAPI.HasHorzScroll(this);
}
}
public event VlnFlexGridEvent OpenAnnotations;
public void OnOpenAnnotations(object sender, EventArgs args)
{
if (OpenAnnotations != null) OpenAnnotations(sender, args);
}
public event VlnFlexGridCursorMovementEvent CursorMovement;
internal void OnCursorMovement(object sender, VlnFlexGridCursorMovementEventArgs args)
{
if (CursorMovement != null) CursorMovement(sender, args);
}
public event VlnFlexGridPasteEvent AdjustPastedText;
internal string OnAdjustPastedText(object sender, VlnFlexGridPasteEventArgs args)
{
if (AdjustPastedText != null) return AdjustPastedText(sender, args);
return args.Text;
}
public event VlnFlexGridkeyEvent EnterKeyPressed;
public void OnEnterKeyPressed(object sender, KeyEventArgs args)
{
if (EnterKeyPressed != null) EnterKeyPressed(sender, args);
}
private TableCellEditor _tableCellEditor;
public TableCellEditor TableCellEditor
{
get { return _tableCellEditor; }
set { _tableCellEditor = value; }
}
private TableClipBoardFuncts _clpbrdCpyPste;
private int _minColSplitWidth = 10;
//private int _minRowSplitHeight = 23;
//private int _minSplitColWidth = 10;
//private int _minSplitRowHeight = 20;
private E_ViewMode _vwMode = E_ViewMode.Edit;
[XmlIgnore]
internal E_ViewMode VwMode
{
get { return _vwMode; }
set
{
_vwMode = value;
AllowEditing = _vwMode == E_ViewMode.Edit;
}
}
private bool _IsRoTable = false;
public bool IsRoTable
{
get { return _IsRoTable; }
set { _IsRoTable = value; }
}
private int _RODbId;
public int RODbId
{
get { return _RODbId; }
set { _RODbId = value; }
}
private string _ROID;
public string ROID
{
get { return _ROID; }
set { _ROID = value; }
}
private float? _DPI = null;
public float? DPI
{
get
{
if (_DPI == null)
_DPI = 120;
return _DPI;
}
set
{
if (DPI != value)
{
_DPI = value;
}
}
}
#region Grid Initialize
public VlnFlexGrid()
{
InitializeComponent();
SetupGrid(4, 3); // use a default row and column count
}
public VlnFlexGrid(int rows, int cols)
{
InitializeComponent();
SetupGrid(rows, cols);
}
public VlnFlexGrid(IContainer container)
{
container.Add(this);
InitializeComponent();
SetupGrid(1, 1);
}
public VlnFlexGrid(ContentItem ci)
{
InitializeComponent();
SetupGrid(4, 3); // use a default row and column count
_MyItemInfo = ci.MyItem.MyItemInfo;
}
//public VlnFlexGrid(IContainer container)
//{
// container.Add(this);
// InitializeComponent();
// _tableCellEditor = new TableCellEditor(this);
// _tableCellEditor.ContentsResized += new ContentsResizedEventHandler(_tableCellEditor_ContentsResized);
//}
//void _tableCellEditor_ContentsResized(object sender, ContentsResizedEventArgs e)
//{
// if (_tableCellEditor._initializingEdit) return;
// CellRange cr = GetMergedRange(Row, Col);
// int oH = cr.UserData == null? 0 : (int)cr.UserData;
// int nH = _tableCellEditor.ContentsRectangle.Height;
// int Hadj = (nH - oH);
// cr.UserData = _tableCellEditor.ContentsRectangle.Height;
// int cellHeight = GetCellHeight(Row,Col);
// int cellheightNLines = cellHeight / (Rows.DefaultSize - 3);
// int nHNLines = nH / (Rows.DefaultSize - 3);
// if (Hadj != 0)
// {
// int curHeight = (Rows[Row].Height == -1) ? Rows.DefaultSize : Rows[Row].Height;
// //if (Hadj > 0 && cellHeight <= oH)
// if (Hadj > 0 && cellheightNLines < nHNLines)
// curHeight += (Rows.DefaultSize - 3);
// if (Hadj < 0 && CanReduceRow())
// curHeight -= (Rows.DefaultSize-3);
// Rows[Row].Height = curHeight;
// AdjustGridControlSize();
// }
// //cr.UserData = _tableCellEditor.ContentsRectangle.Height;
// //int mh = GetMaxRowHeight();
// ////Rows[Row].Height = mh + 2;
// //int h = 0;
// //if (cr.r1 == cr.r2 && cr.c1 == cr.c2)
// // h = Rows[Row].Height - 2;
// //else
// //{
// // for (int r = cr.r1; r <= cr.r2; r++)
// // h += Rows[r].Height - 2;
// //}
// //Rows[Row].Height += (mh - h);
// ////AdjustGridControlSize();
//}
private int GetCellHeight(int row, int col)
{
return GetRangeHeight(GetMergedRange(row, col))-3;
}
public int GetRangeHeight(CellRange cr)
{
int height = 0;
for (int r = cr.r1; r <= cr.r2; r++)
height += (Rows[r].Height == -1) ? Rows.DefaultSize : Rows[r].Height;
return height;
}
public int GetRangeTop(CellRange cr)
{
int top = 0;
for (int r = 0; r < cr.r1; r++)
top += (Rows[r].Height == -1) ? Rows.DefaultSize : Rows[r].Height;
return top;
}
public int GetRangeWidth(CellRange cr)
{
int width = 0;
for (int c = cr.c1; c <= cr.c2; c++)
width += (Cols[c].Width == -1) ? Cols.DefaultSize : Cols[c].Width;
return width;
}
public int GetRangeLeft(CellRange cr)
{
int left = 0;
for (int c = 0; c < cr.c1; c++)
left += (Cols[c].Width == -1) ? Cols.DefaultSize : Cols[c].Width;
return left;
}
public int GetRangeRowsMin(CellRange cr)
{
int rowsMin = 1 + cr.r2 - cr.r1;
for (int c = cr.c1; c <= cr.c2; c++)
{
int rows = 0;
for (int r = cr.r1; r <= cr.r2; r++)
{
CellRange chk = GetMergedRange(r, c);
if (chk.r1 == r && chk.c1 == c)
rows++;
}
rowsMin = Math.Min(rowsMin, rows);
}
return rowsMin;
}
public int GetRangeRowsMax(CellRange cr)
{
int rowsMax = 0;
for (int c = cr.c1; c <= cr.c2; c++)
{
int rows = 0;
for (int r = cr.r1; r <= cr.r2; r++)
{
CellRange chk = GetMergedRange(r, c);
if (chk.r1 == r && chk.c1 == c)
rows++;
}
rowsMax = Math.Max(rowsMax, rows);
}
return rowsMax;
}
public int GetRangeColsMin(CellRange cr)
{
int colsMin = 1 + cr.c2 - cr.c1;
for (int r = cr.r1; r <= cr.r2; r++)
{
int cols = 0;
for (int c = cr.c1; c <= cr.c2; c++)
{
CellRange chk = GetMergedRange(r, c);
if (chk.r1 == r && chk.c1 == c)
cols++;
}
colsMin = Math.Min(colsMin, cols);
}
return colsMin;
}
public int GetRangeColsMax(CellRange cr)
{
int colsMax = 0;
for (int c = cr.c1; c <= cr.c2; c++)
{
int cols = 0;
for (int r = cr.r1; r <= cr.r2; r++)
{
CellRange chk = GetMergedRange(r, c);
if (chk.r1 == r && chk.c1 == c)
cols++;
}
colsMax = Math.Max(colsMax, cols);
}
return colsMax;
}
public string GetRangeRowList(CellRange cr)
{
StringBuilder sb = new StringBuilder();
string sep = "";
for (int r = cr.r1; r <= cr.r2; r++)
{
CellRange crm = GetMergedRange(r, cr.c1);
if (crm.r1 == r)
{
sb.Append(sep + r.ToString());
sep = ".";
}
r = crm.r2;
}
return sb.ToString();
}
private int BlankRowSpace()
{
int curRowHeight = (Rows[Row].Height == -1) ? Rows.DefaultSize - 3 : Rows[Row].Height - 3;
if (curRowHeight <= (Rows.DefaultSize - 3)) return 0; // never have row less than default height
int blankRowSpace = curRowHeight;
for (int c = 0; c < Cols.Count; c++)
{
CellRange cr = GetMergedRange(Row, c);
if (Row >= cr.r1 && Row <= cr.r2)
{
int cellHeight = GetCellHeight(Row, c);
int dataHeight = (cr.UserData == null) ? cellHeight : (int)cr.UserData;
int ud = dataHeight / (Rows.DefaultSize - 3);
//if (cellHeight < dataHeight)
// Console.WriteLine("r {0}, c {1}, cell{2}, data{3}", Row, c, cellHeight, dataHeight);
blankRowSpace = Math.Min(blankRowSpace, Math.Max(0,cellHeight - dataHeight));
}
}
//Console.WriteLine("BlankRowSpace {0}", blankRowSpace);
return blankRowSpace;
}
private int GetCellWidth(int row, int col)
{
int width = 0;
CellRange cr = GetMergedRange(row, col);
for (int c = cr.c1; c <= cr.c2; c++)
{
width += (Cols[c].Width == -1) ? Cols.DefaultSize - 3 : Cols[c].Width -3;
}
return width;
}
private int BlankColSpace()
{
int curColWidth = (Cols[Col].Width == -1) ? Cols.DefaultSize - 3 : Cols[Col].Width-3;
//int curRowHeightNLines = curRowHeight / (Rows.DefaultSize - 3);
if (curColWidth <= Cols.DefaultSize - 3) return 0; // never have col less than default width
int blankColSpace = curColWidth;
for (int r = 0; r < Rows.Count; r++)
{
using (StepRTB srtb = new StepRTB())
{
CellRange cr = GetMergedRange(r, Col);
srtb.Rtf = GetCellRTFString(cr.r1, cr.c1);
if (Col >= cr.c1 && Col <= cr.c2)
{
int cellWidth = GetCellWidth(r, Col);
//srtb.Width = cellWidth;
srtb.AdjustWidthForContent();
//Application.DoEvents();
//int mergeCellHeightNLines = cellHeight / (Rows.DefaultSize - 3);
//int dataHeight = (cr.UserData == null) ? cellHeight : (int)cr.UserData;
//int ud = dataHeight / (Rows.DefaultSize - 3);
//if (cellHeight < dataHeight)
// Console.WriteLine("r {0}, c {1}, cell{2}, data{3}", Row, c, cellHeight, dataHeight);
//blankColSpace = Math.Min(blankColSpace, Math.Max(0, cellWidth - srtb.MaxTextWidth));
blankColSpace = Math.Min(blankColSpace, Math.Max(0, cellWidth - srtb.Width));
}
}
}
//Console.WriteLine("BlankRowSpace {0}", blankRowSpace);
return blankColSpace;
}
//private bool CanReduceRow()
//{
// int curRowHeight = (Rows[Row].Height == -1) ? Rows.DefaultSize - 3 : Rows[Row].Height - 3;
// int curRowHeightNLines = curRowHeight / (Rows.DefaultSize - 3);
// bool bReduce = (curRowHeight > (Rows.DefaultSize - 3));
// if (bReduce)
// {
// for (int c = 0; c < Cols.Count; c++)
// {
// CellRange cr = GetMergedRange(Row, c);
// if (Row >= cr.r1 && Row <= cr.r2)
// {
// int mergeCellHeightNLines = GetCellHeight(Row, c) / (Rows.DefaultSize - 3);
// //int ud = (cr.UserData == null) ? 0 : (int)cr.UserData;
// //if ((c != Col) && curRowHeight <= ud && ud >= mergeCellHeight)
// // bReduce = false;
// int ud = ((cr.UserData == null) ? 0 : (int)cr.UserData) / (Rows.DefaultSize - 3);
// if ((c != Col) && curRowHeightNLines <= ud && ud >= mergeCellHeightNLines)
// bReduce = false;
// }
// }
// }
// //Console.WriteLine("canreduce {0}, {1}", Row, bReduce);
// return bReduce;
//}
//private int GetMaxRowHeight()
//{
// int maxRTFHeight = _minRowSplitHeight; //Rows.DefaultSize;// the smallest a row can be
// Console.WriteLine("=================================================================");
// for (int c = 0; c < Cols.Count; c++)
// {
// CellRange cr = GetMergedRange(Row, c);//GetCellRange(Row, c);
// maxRTFHeight = Math.Max(maxRTFHeight, (int)cr.UserData);
// if (c == 0)
// Console.WriteLine("Height in Row[{0}] = {1}", Row, Rows[Row].Height);
// Console.WriteLine("UserData Cell[{0},{1}] = {2}", Row, c, cr.UserData);
// }
// return maxRTFHeight;
//}
private bool IsInMergeRange(int row, int col)
{
//foreach (CellRange cr in this.MergedRanges)
//{
// if (cr.Contains(row, col))
// return true; // in a merged range
//}
CellRange cr = GetMergedRange(row, col);
return (cr.r1 == row && cr.c1 == col);
}
private bool _ReadingXml = false;
public bool ReadingXml
{
get { return _ReadingXml; }
}
private static Regex _ReplaceVESymbFix = new Regex(@"({\\f[0-9]+[^ ]* )(VESymbFix)(;})");
private static Regex _ReplaceArialUnicodeMS = new Regex(@"({\\f[0-9]+[^ ]* )(Arial Unicode MS)(;})");
private static Regex _ReplaceTextFont = new Regex(@"({\\f[0-9]+[^ ]* )(?((?!VESymbFix)(?!Arial Unicode MS))([^;]*)|(!!!!))(;})");
public void LoadGrid(ItemInfo itemInfo)
{
_MyItemInfo = itemInfo;
string str = itemInfo.MyContent.MyGrid.Data;
VE_Font vefont = _MyItemInfo.GetItemFont();
FontFamily ff = StepRTB.MyFontFamily ?? vefont.WindowsFont.FontFamily; // TODO: Does not change fixed font.
if (StepRTB.MySymbolFontName != "VESymbFix")
str = _ReplaceVESymbFix.Replace(str, "$1" + StepRTB.MySymbolFontName + "$3");
if (StepRTB.MySymbolFontName != "Arial Unicode MS")
str = _ReplaceArialUnicodeMS.Replace(str, "$1" + StepRTB.MySymbolFontName + "$3");
str = _ReplaceTextFont.Replace(str, "$1" + ff.Name + "$4");
// To prevent scroll bars from being flashed on/off
// - save an image of the current grid
// - set Visible to false
// - draw the saved grid image
// - do the the load/reload of the grid
// - set Visible back to true.
System.Drawing.Image img = this.CreateImage();
Visible = false;
if (Parent is GridItem)
{
using (Graphics gr = (Parent as GridItem).CreateGraphics())
{
gr.DrawImage(img, Left, Top);
}
}
Clear();
MergedRanges.Clear();
_ReadingXml = true;
//Console.WriteLine("LoadGrid - Before ReadXML");
using (StringReader sr = new StringReader(str))
{
ReadXml(sr);
this.BorderStyle = C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.None;
sr.Close();
}
//Console.WriteLine("LoadGrid - After ReadXML");
_ReadingXml = false;
Select(-1, -1); // this keeps the cell from being selected when the grid is first displayed
Visible = true;
}
private void SetupGrid(int numrows, int numcols) //C1FlexGrid NewGrid()
{
// setup the default size of each cell in the table/grid
this.Cols.DefaultSize = (int) DPI;
this.Rows.DefaultSize = 20;
// setup the number of rows and columns
this.Rows.Count = numrows;
this.Cols.Count = numcols;
// make all the cell editable
this.Rows.Fixed = 0;
this.Cols.Fixed = 0;
this.DrawMode = DrawModeEnum.OwnerDraw;
this.ScrollBars = ScrollBars.None;
// grid styles
this.Styles.EmptyArea.BackColor = Color.Transparent;
this.Styles.EmptyArea.Border.Style = BorderStyleEnum.None;
this.Styles.Normal.Border.Color = Color.Black;
this.Styles.Normal.TextAlign = C1.Win.C1FlexGrid.TextAlignEnum.LeftTop;
//SetupCellStyles();
this.FocusRect = FocusRectEnum.Solid;
this.Styles.Highlight.BackColor = Color.LightCyan;
this.Styles.Highlight.ForeColor = Color.Black;
this.Styles.Focus.BackColor = Color.LightCyan;
this.HighLight = HighLightEnum.WithFocus;
_DefaultCellBackgroundcolor = this.StyleBackColor;
_DefaultFixedBackgroundColor = this.Styles.Fixed.BackColor;
this.AllowMerging = C1.Win.C1FlexGrid.AllowMergingEnum.Custom;
this.AllowResizing = C1.Win.C1FlexGrid.AllowResizingEnum.Both;
_tableCellEditor = new TableCellEditor(this);
_tableCellEditor.HeightChanged += new StepRTBEvent(_tableCellEditor_HeightChanged);
_clpbrdCpyPste = new TableClipBoardFuncts();
_SpellChecker = _tableCellEditor.SpellCheckerInstance;
this.AfterResizeRow += new C1.Win.C1FlexGrid.RowColEventHandler(this.Grid_AfterResize);
this.StartEdit += new C1.Win.C1FlexGrid.RowColEventHandler(this._StartEdit);
this.AfterEdit += new C1.Win.C1FlexGrid.RowColEventHandler(this._AfterEdit);
this.AfterScroll += new C1.Win.C1FlexGrid.RangeEventHandler(this._AfterScroll);
this.AfterResizeColumn += new C1.Win.C1FlexGrid.RowColEventHandler(this.Grid_AfterResize);
this.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this._KeyPress);
this.OwnerDrawCell += new OwnerDrawCellEventHandler(this.Grid_OwnerDrawCell);
this.LeaveCell += new EventHandler(VlnFlexGrid_LeaveCell);
this.KeyDown += new KeyEventHandler(VlnFlexGrid_KeyDown);
this.KeyUp +=new KeyEventHandler(VlnFlexGrid_KeyUp);
TableCellEditor.EditMode = TableCellEditor.Visible; // need to comment out for compile for only jsj - 07FEB2011
this.MouseDown += new MouseEventHandler(VlnFlexGrid_MouseDown);
}
private bool _FirstEntry = false;
public bool FirstEntry
{
get { return _FirstEntry; }
set { _FirstEntry = value; }
}
void VlnFlexGrid_MouseDown(object sender, MouseEventArgs e)
{
int left = 0;
int top = 0;
int col = 0;
int row = 0;
int strow = Selection.r1;
int stcol = Selection.c1;
int erow = Selection.r2;
int ecol = Selection.c2;
while (e.X > left && col < Cols.Count)
{
left += Cols[col].Width > 0 ? Cols[col].Width : Cols.DefaultSize;
col++;
}
while (e.Y > top && row < Rows.Count)
{
top += Rows[row].Height > 0 ? Rows[row].Height : Rows.DefaultSize;
row++;
}
col--;
row--;
//Console.WriteLine("Mousedown Selection {0}", Selection);
//Console.WriteLine("Mousedown Row, Col [{0},{1}]", row, col);
erow = Math.Max(erow, row);
ecol = Math.Max(ecol, col);
if (_FirstEntry)
Select(row, col);
else
Select(strow, stcol, erow, ecol);
_FirstEntry = false;
}
void _tableCellEditor_HeightChanged(object sender, EventArgs args)
{
if (_tableCellEditor._initializingEdit || !_tableCellEditor.Visible) return;
int curHeight = GetCellHeight(Row, Col);//(Rows[Row].Height == -1) ? Rows.DefaultSize : Rows[Row].Height;
CellRange cr = GetMergedRange(Row, Col);
int oH = cr.UserData == null ? curHeight : (int)cr.UserData;
int nH = _tableCellEditor.Height; //.ContentsRectangle.Height;
int Hadj = (nH - curHeight);//oH);
cr.UserData = _tableCellEditor.Height; //.ContentsRectangle.Height;
//int cellHeight = GetCellHeight(Row, Col);
//int cellheightNLines = cellHeight / (Rows.DefaultSize - 3);
//int nHNLines = nH / (Rows.DefaultSize - 3);
if (Hadj != 0)
{
//if (Hadj > 0 && cellHeight <= oH)
//if (Hadj > 0 && cellheightNLines < nHNLines)
// curHeight += (Rows.DefaultSize - 3);
//if (Hadj < 0 && CanReduceRow())
// curHeight -= (Rows.DefaultSize - 3);
int blankRowSpace = BlankRowSpace();
if (Hadj < 0)
Hadj = -Math.Min(-Hadj, blankRowSpace);
//if (Hadj > 0)
// Console.WriteLine("r {0}, nh {1}, curh{2}", Row, nH, curHeight);
if (Hadj != 0)
{
int newHeight = Hadj + ((Rows[Row].Height < 0) ? Rows.DefaultSize : Rows[Row].Height);
//Rows[Row].Height += Hadj;//= curHeight;
Rows[Row].Height = newHeight;
AdjustGridControlSize();
}
}
}
void VlnFlexGrid_KeyUp(object sender, KeyEventArgs e)
{
if (e.Control)
{
if (e.Alt)
{
switch (e.KeyCode)
{
case Keys.M:
OnOpenAnnotations(this, new EventArgs());
e.Handled = true;
break;
default:
break;
}
}
}
}
void VlnFlexGrid_KeyDown(object sender, KeyEventArgs e)
{
switch (e.KeyCode)
{
case Keys.Left:
if (e.Shift) return;
_tableCellEditor.StepRTB_ArrowPressed(e.Control ? E_ArrowKeys.CtrlLeft : E_ArrowKeys.Left);
e.Handled = true;
break;
case Keys.Up:
if (e.Shift) return;
_tableCellEditor.StepRTB_ArrowPressed(e.Control ? E_ArrowKeys.CtrlUp : E_ArrowKeys.Up);
e.Handled = true;
break;
case Keys.Right:
if (e.Shift) return;
if (IsRoTable) Select(Rows.Count - 1, Cols.Count - 1);
_tableCellEditor.StepRTB_ArrowPressed(e.Control ? E_ArrowKeys.CtrlRight : E_ArrowKeys.Right);
e.Handled = true;
break;
case Keys.Down:
if (e.Shift) return;
if (IsRoTable) Select(Rows.Count - 1, 0);
_tableCellEditor.StepRTB_ArrowPressed(e.Control ? E_ArrowKeys.CtrlDown : E_ArrowKeys.Down);
e.Handled = true;
break;
case Keys.Enter:
//if (e.Shift) return;
//Select(Rows.Count - 1, 0);
//_tableCellEditor.StepRTB_ArrowPressed(E_ArrowKeys.Down);
//e.Handled = true;
if (!e.Control && !e.Shift && !e.Alt)
{
OnEnterKeyPressed(sender, e);
}
break;
}
}
void VlnFlexGrid_LeaveCell(object sender, EventArgs e)
{
//CellStyle csd = this.CursorCell.StyleDisplay;
//CellStyle cs = this.GetCellRange(Row, Col).Style;
//if (cs != null)
//{
// Console.WriteLine("LeaveCell Style = {0}", cs.Name);
// Console.WriteLine("LeaveCell StyleDisplay = {0}", csd.Name);
// cs.ForeColor = Color.Black;
//}
CellStyle cs = this.Styles["Focus"];
cs.ForeColor = Color.Black;
cs = this.Styles["Highlight"];
cs.ForeColor = Color.Black;
}
//void VlnFlexGrid_LeaveEdit(object sender, RowColEventArgs e)
//{
// //Console.WriteLine("LeaveEdit Style = {0}", this.GetCellRange(e.Row, e.Col).Style.Name);
// this.GetCellRange(e.Row, e.Col).Style.ForeColor = Color.Black;
//}
private void Grid_OwnerDrawCell(object sender, C1.Win.C1FlexGrid.OwnerDrawCellEventArgs e)
{
using (RTF _rtf = new RTF())
{
// use nearest solid color
// (the RTF control doesn't dither, and doesn't support transparent backgrounds)
Color solid = e.Graphics.GetNearestColor(e.Style.BackColor);
DPI = e.Graphics.DpiX;
if (e.Style.BackColor != solid)
e.Style.BackColor = solid;
// check whether the cell contains RTF
string rtfText = this.GetDataDisplay(e.Row, e.Col).Replace(@"\~", @"\u160?");
GridItem gi = Parent as GridItem;
if (gi != null)
{
DisplayText dt = new DisplayText(gi.MyItemInfo, rtfText, true);
rtfText = dt.StartText;
}
// it does, so draw background
e.DrawCell(DrawCellFlags.Background);
if (rtfText.StartsWith(@"{\rtf"))
{
// Please add a comment if this value needs to be changed
_rtf.Rtf = rtfText;
// draw the RTF text
if (e.Bounds.Width > 0 && e.Bounds.Height > 0)
{
_rtf.Width = e.Bounds.Width - 1; // This has also been -3 which matchs the rener command
CellRange cr = GetMergedRange(e.Row, e.Col);
cr.UserData = _rtf.Height;
int hAdjust = 0;
int hDiff = e.Bounds.Height - _rtf.Height;
if (hDiff < 0)
{
Rows[e.Row].Height = _rtf.Height + 4;
AdjustGridControlSize();
hDiff = 0;
}
if (e.Style != null)
{
switch (e.Style.TextAlign)
{
case TextAlignEnum.CenterBottom:
case TextAlignEnum.GeneralBottom:
case TextAlignEnum.LeftBottom:
case TextAlignEnum.RightBottom:
hAdjust = hDiff;
break;
case TextAlignEnum.CenterCenter:
case TextAlignEnum.GeneralCenter:
case TextAlignEnum.LeftCenter:
case TextAlignEnum.RightCenter:
hAdjust = hDiff / 2;
break;
default:
break;
}
}
if (IsRoTable)
{
_rtf.ForeColor = Color.Red;
}
else
{
_rtf.ForeColor = e.Style.ForeColor;
}
_rtf.BackColor = e.Style.BackColor;
_rtf.Render(e.Graphics, new Rectangle(e.Bounds.X + 1, e.Bounds.Y + hAdjust, e.Bounds.Width - 3, e.Bounds.Height));
}
}
else
_rtf.Text = rtfText;
// spell check unless (we're just measuring)
if (!e.Measuring)
{
CharRangeList errors = SpellChecker.CheckText(_rtf.Text);//(text);
// underline errors
if (errors.Count > 0)
{
CharacterRange[] ranges = new CharacterRange[1];
ranges[0] = new CharacterRange(0, 1);
Pen pn = new Pen(Color.Green, 2);
StringFormat sf = new StringFormat(e.Style.StringFormat);
sf.SetMeasurableCharacterRanges(ranges);
Rectangle rc = e.Style.GetTextRectangle(e.Bounds, null);
Region[] rgns = e.Graphics.MeasureCharacterRanges(_rtf.Text, e.Style.Font, rc, sf);//(text, e.Style.Font, rc, sf);
float btm = rgns[0].GetBounds(e.Graphics).Bottom;
float top = rgns[0].GetBounds(e.Graphics).Top;
int adj = (int)(btm - top);
for (int i = 0; i < errors.Count; i++)
{
// The positioning of the the squigle line does not account for mixed font sizes
// should we support having mixed fonts in the table cells, we will need to add
// logic to support it.
Point ptStart = _rtf.GetPositionFromCharIndex(errors[i].Start);
Point ptEnd = _rtf.GetPositionFromCharIndex(errors[i].Start + errors[i].Length);
SquigleLine(e.Graphics, e.Bounds.Left + ptStart.X, e.Bounds.Top + ptStart.Y + adj, e.Bounds.Left + ptEnd.X);
}
}
}
// and draw border last
//e.DrawCell(DrawCellFlags.Border);
// This can be used to draw more specific borders
DrawCellBorder(e);
// we're done with this cell
e.Handled = true;
}
}
private void SquigleLine(Graphics graphics, int x1, int y1, int x2)
{
for (Point pt = new Point(x1, y1); pt.X + 2 < x2; pt.X += 4)
{
//Console.WriteLine("squiggle point {0}", pt);
graphics.DrawLines(Pens.Red, new Point[]
{
new Point(pt.X, pt.Y),
new Point(pt.X + 2, pt.Y - 2),
new Point(pt.X + 4, pt.Y)
});
}
}
private static Color _BorderColor = Color.Black;
public static Color BorderColor
{
get { return VlnFlexGrid._BorderColor; }
set { VlnFlexGrid._BorderColor = value; }
}
private void DrawCellBorder(C1.Win.C1FlexGrid.OwnerDrawCellEventArgs e)
{
Graphics grGrid =e.Graphics;
Rectangle bounds = e.Bounds;
int row = e.Row;
int col = e.Col;
CellRange cr = GetMergedRange(row, col);
GridLinePattern topSide = MyBorders.HorizontalLines[cr.r1,cr.c1];
GridLinePattern rightOfTopSide = cr.c2 == Cols.Count - 1 ? GridLinePattern.None : MyBorders.HorizontalLines[cr.r1, cr.c2 + 1];
GridLinePattern leftOfTopSide = cr.c1 == 0? GridLinePattern.None : MyBorders.HorizontalLines[cr.r1, cr.c1 - 1];
GridLinePattern leftSide = MyBorders.VerticalLines[cr.r1, cr.c1];
GridLinePattern aboveLeftSide = cr.r1 == 0 ? GridLinePattern.None : MyBorders.VerticalLines[cr.r1 - 1, cr.c1];
GridLinePattern belowLeftSide = cr.r2 == Rows.Count - 1 ? GridLinePattern.None : MyBorders.VerticalLines[cr.r2 + 1, cr.c1];
GridLinePattern bottomSide = MyBorders.HorizontalLines[cr.r2+1, cr.c2];
GridLinePattern rightOfBottomSide = cr.c2 == Cols.Count - 1 ? GridLinePattern.None : MyBorders.HorizontalLines[cr.r2 + 1, cr.c2 + 1];
GridLinePattern rightSide = MyBorders.VerticalLines[cr.r2, cr.c2+1];
GridLinePattern belowRightSide = cr.r2 == Rows.Count - 1 ? GridLinePattern.None : MyBorders.VerticalLines[cr.r2 + 1, cr.c2 + 1];
GridLinePattern none = GridLinePattern.None;
int x1 = bounds.Left;
int y1 = bounds.Top;
int x2 = bounds.Right - 1;
int y2 = bounds.Bottom - 1;
GridItem myGridItem = Parent as GridItem;
Panel myPanel = Parent as Panel;
if (myGridItem == null && myPanel == null) return;
if (row == 0 || col == 0) // Top or Left Edge - Draw on parent
{
using (Graphics grParent = myGridItem != null ? myGridItem.CreateGraphics() : myPanel.CreateGraphics())
{
if (row == 0)
{
if (col == 0)
{
// Draw the top left intersection
DrawIntersection(grParent, Left - 3, Top-1, none, topSide,leftSide, none);
}
// Draw the top right intersection
DrawIntersection(grParent, Left +x2 - 2, Top-1, none, rightOfTopSide,rightSide,topSide);
// Draw the top side on the parent
DrawLine(grParent, topSide, Left + x1, Top + y1 - 1, Left + x2-3, Top + y1 -1);
}
if (col == 0)
{
// Draw the bottom left intersection
DrawIntersection(grParent, Left -3, Top + y2, leftSide,bottomSide,belowLeftSide,none);
// Draw the left side
DrawLine(grParent, leftSide, Left + x1 - 1, Top + y1, Left + x1 - 1, Top + y2-3);
}
}
}
// Draw the bottom right intersection
DrawIntersection(grGrid, x2 - 2, y2, rightSide, rightOfBottomSide, belowRightSide, bottomSide);
// Draw the bottom side
DrawLine(grGrid, bottomSide, x1, y2, x2-3, y2);
// Draw the right side
DrawLine(grGrid, rightSide, x2, y1, x2, y2-3);
}
private static void DrawLine(Graphics gr, GridLinePattern pattern, int x1, int y1, int x2, int y2)
{
if (pattern == GridLinePattern.None) return;
Pen pn = VlnBorders.LinePen(pattern, BorderColor);
DrawLine(gr, pn, pattern, x1, y1, x2, y2);
}
private static void DrawLine(Graphics gr, Pen pn, int x1, int y1, int x2, int y2)
{
DrawLine(gr, pn, GridLinePattern.Single, x1, y1, x2, y2);
}
private static void DrawLine(Graphics gr, Pen pn, GridLinePattern pattern, int x1, int y1, int x2, int y2)
{
int dx = 0;
int dy = 0;
int dblx = 0;
int dbly = 0;
int xThick = 0;
int yThick = 0;
if (x1 == x2) // Vertical Line
{
dx = (int) (-pn.Width / 2);
dblx = -2;
if (pn.Width > 2)
yThick = 1;
}
else // Horizontal Line
{
dy = (int) (-pn.Width / 2);
dbly = -2;
if (pn.Width > 2)
xThick = 1;
}
gr.DrawLine(pn, x1 + dx, y1 + dy, x2 + dx + xThick, y2 + dy + yThick);
if(pattern == GridLinePattern.Double)
gr.DrawLine(pn, x1 + dx +dblx, y1 + dy + dbly, x2 + dx+dblx, y2 + dy+dbly);
}
private static void DrawIntersection(Graphics gr, int x, int y, GridLinePattern up, GridLinePattern right, GridLinePattern down, GridLinePattern left)
{
if (up == GridLinePattern.Double)
if (right == GridLinePattern.Double)
if (down == GridLinePattern.Double)
if (left == GridLinePattern.Double) DrawIntersectionAllDoubles(gr, x, y);
else DrawDrawIntersection3Doubles_URD(gr, x, y);
else // Down is not double
if (left == GridLinePattern.Double) DrawDrawIntersection3Doubles_URL(gr, x, y);
else DrawDrawIntersection2Doubles_UR(gr, x, y, down, left);
else // right is not double
if (down == GridLinePattern.Double)
if (left == GridLinePattern.Double) DrawDrawIntersection3Doubles_UDL(gr, x, y);
else DrawDrawIntersection2Doubles_UD(gr, x, y, right, left);
else // Down is not double
if (left == GridLinePattern.Double) DrawIntersection2Doubles_UL(gr, x, y, right, down);
else DrawIntersectionOneDoubleOrLess(gr, x, y, up, right, down, left);
else
if (right == GridLinePattern.Double)
if (down == GridLinePattern.Double)
if (left == GridLinePattern.Double) DrawDrawIntersection3Doubles_RDL(gr, x, y);
else DrawDrawIntersection2Doubles_RD(gr, x, y, up, left);
else // Down is not double
if (left == GridLinePattern.Double) DrawDrawIntersection2Doubles_RL(gr, x, y, up, down);
else DrawIntersectionOneDoubleOrLess(gr, x, y, up, right, down, left);
else
if (down == GridLinePattern.Double)
if (left == GridLinePattern.Double) DrawDrawIntersection2Doubles_DL(gr, x, y, up, right);
else DrawIntersectionOneDoubleOrLess(gr, x, y, up, right, down, left);
else // These both use the same function with the same parameters
if (left == GridLinePattern.Double) DrawIntersectionOneDoubleOrLess(gr, x, y, up, right, down, left);
else DrawIntersectionOneDoubleOrLess(gr, x, y, up, right, down, left);
}
private static Pen pnDouble = VlnBorders.LinePen(GridLinePattern.Double, BorderColor);
private static Pen pnThick = VlnBorders.LinePen(GridLinePattern.Thick, BorderColor);
private static void DrawIntersectionAllDoubles(Graphics gr, int x, int y)
{
DrawLine(gr, pnDouble, x-1, y, x, y);
DrawLine(gr, pnDouble, x, y - 2, x, y - 3);
DrawLine(gr, pnDouble, x + 2, y - 2, x + 3, y - 2);
DrawLine(gr, pnDouble, x + 2, y, x + 2, y + 1);
}
private static void DrawDrawIntersection3Doubles_URD(Graphics gr, int x, int y)
{
DrawLine(gr, pnDouble, x , y, x, y - 3);
DrawLine(gr, pnDouble, x + 2, y - 2, x + 3, y - 2);
DrawLine(gr, pnDouble, x + 2, y, x + 2, y + 1);
}
private static void DrawDrawIntersection3Doubles_URL(Graphics gr, int x, int y)
{
DrawLine(gr, pnDouble, x, y, x + 2, y);
DrawLine(gr, pnDouble, x -1, y - 2, x , y - 2);
DrawLine(gr, pnDouble, x + 2, y - 2, x + 3, y - 2);
}
private static void DrawDrawIntersection3Doubles_UDL(Graphics gr, int x, int y)
{
DrawLine(gr, pnDouble, x-1, y, x, y);
DrawLine(gr, pnDouble, x , y - 2, x , y - 3);
DrawLine(gr, pnDouble, x + 2, y-3, x + 2, y);
}
private static void DrawDrawIntersection3Doubles_RDL(Graphics gr, int x, int y)
{
DrawLine(gr, pnDouble, x-1, y, x, y);
DrawLine(gr, pnDouble, x, y - 2, x + 2, y - 2);
DrawLine(gr, pnDouble, x + 2, y, x + 2, y + 1);
}
private static void DrawDrawIntersection2Doubles_UR(Graphics gr, int x, int y, GridLinePattern lp1, GridLinePattern lp2)
{
if (lp1 == GridLinePattern.Thick && lp2 == GridLinePattern.Thick)
DrawLine(gr, pnThick, x, y, x + 3, y);
else
{
DrawLine(gr, pnDouble, x, y, x + 2, y);
DrawLine(gr, pnDouble, x , y, x , y - 2);
DrawLine(gr, pnDouble, x + 2, y - 2, x + 3, y - 2);
}
}
private static void DrawDrawIntersection2Doubles_UD(Graphics gr, int x, int y, GridLinePattern lp1, GridLinePattern lp2)
{
if (lp1 == GridLinePattern.Thick && lp2 == GridLinePattern.Thick)
DrawLine(gr, pnThick, x, y, x + 3, y);
else
{
DrawLine(gr, pnDouble, x, y, x, y - 2);
DrawLine(gr, pnDouble, x + 2, y, x + 2, y - 2);
}
}
private static void DrawIntersection2Doubles_UL(Graphics gr, int x, int y, GridLinePattern lp1, GridLinePattern lp2)
{
if (lp1 == GridLinePattern.Thick && lp2 == GridLinePattern.Thick)
DrawLine(gr, pnThick, x, y, x + 3, y);
else
{
DrawLine(gr, pnDouble, x, y, x + 2, y);
DrawLine(gr, pnDouble, x , y - 2, x, y - 3);
DrawLine(gr, pnDouble, x + 2, y, x + 2, y - 2);
}
}
private static void DrawDrawIntersection2Doubles_RD(Graphics gr, int x, int y, GridLinePattern lp1, GridLinePattern lp2)
{
if (lp1 == GridLinePattern.Thick && lp2 == GridLinePattern.Thick)
DrawLine(gr, pnThick, x, y, x + 3, y);
else
{
DrawLine(gr, pnDouble, x, y, x, y - 2);
DrawLine(gr, pnDouble, x, y - 2, x + 2, y - 2);
DrawLine(gr, pnDouble, x + 2, y, x + 2, y + 1);
}
}
private static void DrawDrawIntersection2Doubles_RL(Graphics gr, int x, int y, GridLinePattern lp1, GridLinePattern lp2)
{
if (lp1 == GridLinePattern.Thick && lp2 == GridLinePattern.Thick)
DrawLine(gr, pnThick, x, y, x + 2, y);
else
{
DrawLine(gr, pnDouble, x, y, x + 2, y);
DrawLine(gr, pnDouble, x, y - 2, x + 2, y - 2);
}
}
private static void DrawDrawIntersection2Doubles_DL(Graphics gr, int x, int y, GridLinePattern lp1, GridLinePattern lp2)
{
if (lp1 == GridLinePattern.Thick && lp2 == GridLinePattern.Thick)
DrawLine(gr, pnThick, x, y, x + 2, y);
else
{
DrawLine(gr, pnDouble, x-1, y, x, y);
DrawLine(gr, pnDouble, x, y - 2, x + 2, y - 2);
DrawLine(gr, pnDouble, x + 2, y, x + 2, y - 2);
}
}
private static void DrawIntersectionOneDoubleOrLess(Graphics gr, int x, int y,
GridLinePattern up, GridLinePattern right, GridLinePattern down, GridLinePattern left)
{
Pen pnUp = VlnBorders.LinePen(up, BorderColor);
Pen pnLeft = VlnBorders.LinePen(left, BorderColor);
int widthUpDown = Math.Max(VlnBorders.LineWidth0(up), VlnBorders.LineWidth0(down));
int heightLeftRight = Math.Max(VlnBorders.LineWidth0(left), VlnBorders.LineWidth0(right));
if (heightLeftRight > 0 && widthUpDown > 0)
{
Pen pn = new Pen(BorderColor, widthUpDown);
if(heightLeftRight > 1)
DrawLine(gr, pn, x + 2, y + 1 - heightLeftRight, x + 2, y);
else if(up == GridLinePattern.None) // Work around to set a pixel (actually set two)
DrawLine(gr, pn, x + 2, y, x + 2, y + 1);
}
if (left != GridLinePattern.None)
{
DrawLine(gr, pnLeft, x, y, x + 2 - widthUpDown, y);
if (left == GridLinePattern.Double)
DrawLine(gr, pnLeft, x, y - 2, x + 2 - widthUpDown, y - 2);
}
if (up != GridLinePattern.None)
{
DrawLine(gr, pnUp, x + 2, y - 3 , x + 2, y +1 - heightLeftRight);
if (up == GridLinePattern.Double)
DrawLine(gr, pnUp, x, y - 3, x, y +1 - heightLeftRight);
}
}
#endregion //Grid Initialize
#region Grid and Cell Styles
public void ChangeBackgroundColor(string bckgndColor)
{
CellRange cr = this.Selection;
if (!bckgndColor.EndsWith(";"))
bckgndColor+=";";
string strBckgndColor = string.Format("BackColor:{0}", bckgndColor);
for (int rw = cr.r1; rw <= cr.r2; rw++)
for (int cl = cr.c1; cl <= cr.c2; cl++)
{
CellRange tmp = this.GetCellRange(rw, cl, rw, cl);
string StyleName = string.Format("R{0}C{1}Style", rw, cl);
CellStyle cs = this.Styles.Add(StyleName, tmp.Style);
cs.ParseString(strBckgndColor);
tmp.Style = cs;
}
}
public void ToggleCellTextAlignment()
{
// only used in test program
CellRange cr = this.Selection;
using (StepRTB srtb = new StepRTB())
{
srtb.Rtf = this.GetCellRTFString(cr.r1, cr.c1);
srtb.SelectAll();
int align = (int)srtb.SelectionAlignment;
align = (align + 1) % 3;
srtb.SelectionAlignment = (HorizontalAlignment)align;
this.PutCellRTFString(cr.r1, cr.c1, srtb.Rtf);
}
}
public void RTFTextAlignment(CellRange cr, HorizontalAlignment ha)
{
using (StepRTB srtb = new StepRTB())
{
for (int rw = cr.r1; rw <= cr.r2; rw++)
for (int cl = cr.c1; cl <= cr.c2; cl++)
{
srtb.Rtf = this.GetCellRTFString(rw, cl);
srtb.SelectAll();
srtb.SelectionAlignment = ha;
this.PutCellRTFString(rw, cl, srtb.Rtf);
}
}
}
public void SetTableBorder(C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum border)
{
this.BorderStyle = border;
this.AdjustGridControlSize();
}
public void ChangeCellAlign(CellRange cr, TextAlignEnum newAlign)
{
for (int rw = cr.r1; rw <= cr.r2; rw++)
for (int col = cr.c1; col <= cr.c2; col++)
{
CellRange tmp = this.GetCellRange(rw, col, rw, col);
string StyleName = string.Format("R{0}C{1}Style", rw, col);
CellStyle cs = null;
if (Styles.Contains(StyleName))
cs = Styles[StyleName];
else
cs = this.Styles.Add(StyleName, tmp.Style);
cs.TextAlign = newAlign;
tmp.Style = cs;
}
}
public void ChangeCellBorder(CellRange cr, BorderStyleEnum newBorder)
{
for (int rw = cr.r1; rw <= cr.r2; rw++)
for (int col = cr.c1; col <= cr.c2; col++)
{
CellRange tmp = this.GetCellRange(rw, col, rw, col);
string StyleName = string.Format("R{0}C{1}Style", rw, col);
CellStyle cs = null;
if (Styles.Contains(StyleName))
cs = Styles[StyleName];
else
cs = this.Styles.Add(StyleName, tmp.Style);
cs.Border.Style = newBorder;
tmp.Style = cs;
}
}
public void ListStyles()
{
for (int r = 0; r < Rows.Count; r++)
for (int c = 0; c < Cols.Count; c++)
{
CellRange cr = GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
if (cr.Style != null) Console.WriteLine("{0}, {1}, {2}, {3}", r, c, cr.Style.Name, cr.Style.BackColor);
}
}
}
//public void VerticalCenterText()
//{
// StepRTB myStepRTB = new StepRTB();
// CellRange selRange = this.Selection;
// for (int r = selRange.r1; r <= selRange.r2; r++)
// for (int c = selRange.c1; c <= selRange.c2; c++)
// {
// CellRange mr = this.GetMergedRange(r, c);
// if (mr.r1 == r)
// {
// int editHeight = (int)mr.UserData;
// int cellHeight = GetCellHeight(mr.r1, mr.c1);
// if (editHeight < cellHeight)
// {
// myStepRTB.Rtf = (string)mr.Data;
// RTBAPI.SetSpaceBefore(myStepRTB, (cellHeight - editHeight) / 2);
// PutCellRTFString(mr.r1, mr.c1, myStepRTB.Rtf);
// }
// }
// }
//}
//public void VerticalTopText()
//{
// StepRTB myStepRTB = new StepRTB();
// CellRange selRange = this.Selection;
// for (int r = selRange.r1; r <= selRange.r2; r++)
// for (int c = selRange.c1; c <= selRange.c2; c++)
// {
// CellRange mr = this.GetMergedRange(r, c);
// if (mr.r1 == r)
// {
// myStepRTB.Rtf = (string)mr.Data;
// RTBAPI.SetSpaceBefore(myStepRTB, 0);
// PutCellRTFString(mr.r1, mr.c1, myStepRTB.Rtf);
// }
// }
//}
//public void VerticalBottomText()
//{
// StepRTB myStepRTB = new StepRTB();
// CellRange selRange = this.Selection;
// for (int r = selRange.r1; r <= selRange.r2; r++)
// for (int c = selRange.c1; c <= selRange.c2; c++)
// {
// CellRange mr = this.GetMergedRange(r, c);
// if (mr.r1 == r)
// {
// int editHeight = (int)mr.UserData;
// int cellHeight = GetCellHeight(mr.r1, mr.c1);
// if (editHeight < cellHeight)
// {
// myStepRTB.Rtf = (string)mr.Data;
// RTBAPI.SetSpaceBefore(myStepRTB, (cellHeight - editHeight));
// PutCellRTFString(mr.r1, mr.c1, myStepRTB.Rtf);
// }
// }
// }
//}
//public void SetupCellStyles()
//{
// //CellStyle cs;
// //cs = this.Styles.Add("Dotted");
// //cs.Border.Style = BorderStyleEnum.Dotted;
// //cs = this.Styles.Add("Double");
// //cs.Border.Style = BorderStyleEnum.Double;
// //cs = this.Styles.Add("Fillet");
// //cs.Border.Style = BorderStyleEnum.Fillet;
// //cs = this.Styles.Add("Flat");
// //cs.Border.Style = BorderStyleEnum.Flat;
// //cs = this.Styles.Add("Groove");
// //cs.Border.Style = BorderStyleEnum.Groove;
// //cs = this.Styles.Add("Inset");
// //cs.Border.Style = BorderStyleEnum.Inset;
// //cs = this.Styles.Add("None");
// //cs.Border.Style = BorderStyleEnum.None;
// //cs = this.Styles.Add("Raised");
// //cs.Border.Style = BorderStyleEnum.Raised;
// //cs = this.Styles.Add("CenterRight");
// //cs.TextAlign = TextAlignEnum.RightCenter; //.LeftCenter; // this is being ignored - probably due to RTF conversion
// //cs = this.Styles.Add("Yellow");
// //cs.BackColor = Color.Yellow;
// //cs = this.Styles.Add("Margins");
// //cs.Margins.Bottom = 5;
// //cs.Margins.Top = 10;
// //cs.Margins.Left = 15;
// //cs.Margins.Right = 20;
//}
#endregion //Grid and Cell Styles
#region Grid Size Adjustments
/// <summary>
/// Adjust the grid control size based on the cell sizes.
/// </summary>
public void AdjustGridControlSize()
{
if (Parent is GridItem ? (Parent as GridItem).Initializing : false ) return;
int difW = this.Width - this.ClientSize.Width;
int difH = this.Height - this.ClientSize.Height;
int wid = 0;
if (this != null)
{
foreach (C1.Win.C1FlexGrid.Column col in this.Cols)
wid += (col.Width >= 0) ? col.Width : this.Cols.DefaultSize;
int height = 0;
foreach (C1.Win.C1FlexGrid.Row row in this.Rows)
//height += (row.Height >= 0) ? row.Height : this.Rows.DefaultSize + 2;
height += (row.Height >= 0) ? row.Height : this.Rows.DefaultSize;
this.Size = new Size(wid + difW, height + difH);
}
}
public void ConvertTextCellToRTF(int r, int c)
{
using (StepRTB trtb = new StepRTB())
{
string tstr = null;
bool dummyCharWidth = false;
bool AllowWidthShrink = false;
trtb.SetTableGridCellRTFPrefix(this.Font);
trtb.Clear();
tstr = (string)this[r, c];
trtb.Font = this.Font;
if (tstr != null && tstr.Length > 0)
{
string tsave = tstr;
// regular text has special characters to toggle Bold, Underline, and Italics
// we need to subtract the width of these characters (allow column/row to shrink)
//AllowWidthShrink = RemoveBoldUlineItalicChars(trtb.Rtf);
AllowWidthShrink = tstr.Contains("#Link:");
// this will convert the special characters for Bold, Underline, and Italics
// into RTF commands
//trtb.Rtf = trtb.RtfPrefix + ConvertTableText(trtb.Rtf) + "}";
//string fromRTF = trtb.Rtf;
//string prefix = trtb.RtfPrefix;
//if (tstr.Contains("#Link:")) prefix += @"{\colortbl ;\red255\green0\blue0;}";
//if (tstr.Contains("#Link:"))
// Console.WriteLine("here");
//string jText = trtb.RtfPrefix + ConvertTableText(tstr) + @"\par}";
//trtb.Rtf = jText;
trtb.Rtf = trtb.RtfPrefix + ConvertTableText(tstr) + @"\par}";
//string fromStr = trtb.Rtf;
//if (fromRTF.Contains("SimSun"))
// Console.WriteLine("SimSun");
//else
// Compare(fromRTF, fromStr, tsave);
}
else
{
trtb.Text = "X"; // this is to trick steprtf in giving a char width to fit one character
// note that a space character was too small.
dummyCharWidth = true;
}
// find the needed cell width
trtb.AdjustWidthForContent();
if (dummyCharWidth)
{
trtb.Text = ""; // clear out the dummy character before saving
dummyCharWidth = false;
}
this[r, c] = trtb.Rtf; // save the cleaned up and processed cell text as RTF
this.Select(r, c, false);
CellRange sel = this.Selection;
//sel.UserData = trtb.ContentsRectangle.Height;
// Now adjust the Height and Width in the defined merge ranges
AdjustMergeRangeHeightWidth(r, c, trtb, tstr, AllowWidthShrink);
//// Now see the the selected row,col is in the defined merge ranges
//bool mrgrows = false;
//bool mrgcols = false;
//foreach (CellRange cr in this.MergedRanges)
//{
// if (cr.Contains(r, c))
// {
// if (cr.c1 != cr.c2)
// mrgcols = true; // in a range of merged columns
// if (cr.r1 != cr.r2)
// mrgrows = true; // in a range of merged rows
// continue;
// }
//}
//if (!mrgcols || !mrgrows)
//{
// // IF the row of the selected cell is NOT in merged range
// // then go ahead and adjust the row height (if needed)
// if (!mrgrows)
// {
// // add adjustment for grid and cell borders
// int newheight = trtb.Height + 3;
// //Console.WriteLine("{0} {1} {2} '{3}'", r, c, newheight,trtb.Text);
// if (newheight > this.Rows[r].Height)
// {
// //Console.WriteLine("1 Row {0} Old Height = {1}, New Height = {2}", r, Rows[r].Height, newheight);
// this.Rows[r].Height = newheight;
// }
// }
// // IF the column of the selected cell is NOT in merged range
// // then go ahead and adjust the column width (if needed)
// if (!mrgcols)
// {
// // add adjustment for grid and cell borders
// int newwidth = trtb.Width + 2;
// if (newwidth > this.Cols[c].Width || AllowWidthShrink || r == 0)
// this.Cols[c].Width = newwidth;
// }
//}
//if (mrgrows && tstr != null)
//{
// CellRange cr = GetMergedRange(r, c);
// //Console.WriteLine("grid[{0},{1}] merge = {2}", r, c,cr);
// if (cr.r1 == r && cr.c1 == c)
// {
// // if in merged rows, then make sure the cell's height is large enough
// string[] strary = tstr.Split("\n".ToCharArray());
// // count number of lines of text
// int nlines = strary.Length;
// // count number of rows in merge range
// int nrows = (cr.r2 - cr.r1) + 1;
// //Console.WriteLine("2 Row {0} Height = {1}", cr.r1, Rows[cr.r1].Height);
// while (nlines > nrows)
// {
// // add length to first row in merged range
// int h = this.Rows[cr.r1].Height;
// int defH = Rows.DefaultSize - 3;
// //h = (h == -1) ? _minRowHeight * 2 : h + _minRowHeight;
// h = (h == -1) ? (defH * 2) + 3 : h + defH;
// //h = (h == -1) ? (Rows.DefaultSize + 2) * 2 : h + Rows.DefaultSize + 2;
// //Console.WriteLine("3 Row {0} Old Height = {1}, New Height = {2}", cr.r1, Rows[cr.r1].Height, h);
// this.Rows[cr.r1].Height = h;
// nrows++;
// }
// }
//}
}
}
private void AdjustCellHeightWidth(int r, int c)
{
using (StepRTB trtb = new StepRTB())
{
string tstr = null;
bool dummyCharWidth = false;
bool AllowWidthShrink = false;
trtb.SetTableGridCellRTFPrefix(this.Font);
trtb.Clear();
trtb.Font = this.Font;
trtb.Rtf = (string)this[r, c];
tstr = trtb.Text;
if (tstr != null && tstr.Length > 0)
AllowWidthShrink = tstr.Contains("#Link:");
else
{
trtb.Text = "X"; // this is to trick steprtf in giving a char width to fit one character
// note that a space character was too small.
dummyCharWidth = true;
}
// find the needed cell width
trtb.AdjustWidthForContent();
if (dummyCharWidth)
{
trtb.Text = ""; // clear out the dummy character before saving
dummyCharWidth = false;
}
this.Select(r, c, false);
CellRange sel = this.Selection;
// Now adjust the Height and Width in the defined merge ranges
AdjustMergeRangeHeightWidth(r, c, trtb, tstr, AllowWidthShrink);
}
}
private void AdjustMergeRangeHeightWidth(int r, int c, StepRTB trtb, string tstr, bool AllowWidthShrink)
{
bool mrgrows = false;
bool mrgcols = false;
foreach (CellRange cr in this.MergedRanges)
{
if (cr.Contains(r, c))
{
if (cr.c1 != cr.c2)
mrgcols = true; // in a range of merged columns
if (cr.r1 != cr.r2)
mrgrows = true; // in a range of merged rows
continue;
}
}
if (!mrgcols || !mrgrows)
{
// IF the row of the selected cell is NOT in merged range
// then go ahead and adjust the row height (if needed)
if (!mrgrows)
{
// add adjustment for grid and cell borders
int newheight = trtb.Height + 3;
//Console.WriteLine("{0} {1} {2} '{3}'", r, c, newheight,trtb.Text);
if (newheight > this.Rows[r].Height)
{
//Console.WriteLine("1 Row {0} Old Height = {1}, New Height = {2}", r, Rows[r].Height, newheight);
this.Rows[r].Height = newheight;
}
}
// IF the column of the selected cell is NOT in merged range
// then go ahead and adjust the column width (if needed)
if (!mrgcols)
{
// add adjustment for grid and cell borders
int newwidth = trtb.Width + 3; // 2;
if (newwidth > (this.Cols[c].Width == -1 ? this.Cols.DefaultSize : this.Cols[c].Width) || AllowWidthShrink || r == 0)
this.Cols[c].Width = newwidth;
}
}
if (mrgrows && tstr != null)
{
CellRange cr = GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
// if in merged rows, then make sure the cell's height is large enough
string[] strary = tstr.Split("\n".ToCharArray());
// count number of lines of text
int nlines = strary.Length;
// count number of rows in merge range
int nrows = (cr.r2 - cr.r1) + 1;
//Console.WriteLine("2 Row {0} Height = {1}", cr.r1, Rows[cr.r1].Height);
while (nlines > nrows)
{
// add length to first row in merged range
int h = this.Rows[cr.r1].Height;
int defH = Rows.DefaultSize - 3;
h = (h == -1) ? (defH * 2) + 3 : h + defH;
this.Rows[cr.r1].Height = h;
nrows++;
}
}
}
}
private int TotalColWidths()
{
int cwid = 0;
foreach (Column c in Cols)
{
cwid += ((c.Width > 0) ? c.Width : Cols.DefaultSize);
}
return cwid;
}
/// <summary>
/// This will adjust the column widths of the current table based upon the page width
/// Note: This is for use in creating a new table - not to process an existing table.
/// </summary>
/// <param name="pgWidthPoints"></param>
public void FitTableToPageWidth(int pgWidthPoints)
{
int grdWidth = TotalColWidths();
int pgwidth = (int)((pgWidthPoints / 72) * this._DPI);
if (grdWidth > pgwidth)
{
int difWid = grdWidth - pgwidth;
int colAdj = (difWid / Cols.Count) +(((difWid % Cols.Count) > 0) ? 1 : 0);
foreach (Column c in Cols)
{
int cwid = (c.Width > 0) ? c.Width : Cols.DefaultSize;
if ((cwid - colAdj) > 0)
c.Width = cwid - colAdj;
}
}
}
//private void AdjustCellHeightWidth(int r, int c)
//{
// StepRTB trtb = new StepRTB();
// string tstr = null;
// bool dummyCharWidth = false;
// bool AllowWidthShrink = false;
// trtb.SetTableGridCellRTFPrefix(this.Font);
// trtb.Clear();
// trtb.Font = this.Font;
// trtb.Rtf = (string)this[r, c];
// tstr = trtb.Text;
// if (tstr != null && tstr.Length > 0)
// AllowWidthShrink = tstr.Contains("#Link:");
// else
// {
// trtb.Text = "X"; // this is to trick steprtf in giving a char width to fit one character
// // note that a space character was too small.
// dummyCharWidth = true;
// }
// // find the needed cell width
// trtb.AdjustWidthForContent();
// if (dummyCharWidth)
// {
// trtb.Text = ""; // clear out the dummy character before saving
// dummyCharWidth = false;
// }
// this.Select(r, c, false);
// CellRange sel = this.Selection;
// // Now see the the selected row,col is in the defined merge ranges
// bool mrgrows = false;
// bool mrgcols = false;
// foreach (CellRange cr in this.MergedRanges)
// {
// if (cr.Contains(r, c))
// {
// if (cr.c1 != cr.c2)
// mrgcols = true; // in a range of merged columns
// if (cr.r1 != cr.r2)
// mrgrows = true; // in a range of merged rows
// continue;
// }
// }
// if (!mrgcols || !mrgrows)
// {
// // IF the row of the selected cell is NOT in merged range
// // then go ahead and adjust the row height (if needed)
// if (!mrgrows)
// {
// // add adjustment for grid and cell borders
// int newheight = trtb.Height + 3;
// //Console.WriteLine("{0} {1} {2} '{3}'", r, c, newheight,trtb.Text);
// if (newheight > this.Rows[r].Height)
// {
// //Console.WriteLine("1 Row {0} Old Height = {1}, New Height = {2}", r, Rows[r].Height, newheight);
// this.Rows[r].Height = newheight;
// }
// }
// // IF the column of the selected cell is NOT in merged range
// // then go ahead and adjust the column width (if needed)
// if (!mrgcols)
// {
// // add adjustment for grid and cell borders
// int newwidth = trtb.Width + 2;
// if (newwidth > this.Cols[c].Width || AllowWidthShrink || r == 0)
// this.Cols[c].Width = newwidth;
// }
// }
// if (mrgrows && tstr != null)
// {
// CellRange cr = GetMergedRange(r, c);
// if (cr.r1 == r && cr.c1 == c)
// {
// // if in merged rows, then make sure the cell's height is large enough
// string[] strary = tstr.Split("\n".ToCharArray());
// // count number of lines of text
// int nlines = strary.Length;
// // count number of rows in merge range
// int nrows = (cr.r2 - cr.r1) + 1;
// //Console.WriteLine("2 Row {0} Height = {1}", cr.r1, Rows[cr.r1].Height);
// while (nlines > nrows)
// {
// // add length to first row in merged range
// int h = this.Rows[cr.r1].Height;
// int defH = Rows.DefaultSize - 3;
// h = (h == -1) ? (defH * 2) + 3 : h + defH;
// this.Rows[cr.r1].Height = h;
// nrows++;
// }
// }
// }
//}
//private void Compare(string fromRTF, string fromStr, string rawstr)
//{
// int istart = fromRTF.IndexOf(" ",fromRTF.IndexOf("viewkind"));
// int jstart = fromStr.IndexOf(" ",fromStr.IndexOf("viewkind"));
// for (int i = istart; i < fromRTF.Length; i++)
// {
// int j = i - istart + jstart;
// //else if (fromRTF[i] != fromStr[j])
// if (fromRTF[i] != fromStr[j])
// {
// if (fromRTF.Substring(i, 1) == @"~" && fromStr.Substring(j, 3) == @"'a0")
// {
// //i++;
// jstart += 2;
// }
// else
// {
// Console.WriteLine("fromStr:\r\n'{0}'\r\nfromRTF:\r\n'{1}'", fromStr, fromRTF);
// ShowRawString(rawstr, "rawstr");
// Console.WriteLine("Str:'{0}' , RTF:'{1}'", fromStr.Substring(j, Math.Min(10,fromStr.Length-j-1)), fromRTF.Substring(i, Math.Min(10,fromRTF.Length-i-1)));
// return;
// }
// }
// }
//}
#region DEBUG
//private void ShowRawString(string str, string title)
//{
// Console.WriteLine("Raw Start --{0}:\n", title);
// foreach (char c in str)
// {
// int ic= (int)c;
// if (c!='\n'&&( ic > 126 || ic < 32))
// Console.Write("<<{0:x4}>>", ic);
// else
// Console.Write(c);
// }
// Console.WriteLine("\n-- Raw End:{0}", title);
//}
#endregion
private void Grid_AfterResize(object sender, C1.Win.C1FlexGrid.RowColEventArgs e)
{
this.AdjustGridControlSize();
}
#endregion // Grid Size Adjustments
#region Cell Text
public void MakeRTFcells()
{
// This will spin through all the cells in the grid:
// - convert the text to RTF if needed
// - adjust the grid dimensions based on the cell info.
for (int r = 0; r < this.Rows.Count; r++)
{
this.Rows[r].Height = Rows.DefaultSize;//_minRowHeight;//20;//10;
for (int c = 0; c < this.Cols.Count; c++)
this.ConvertTextCellToRTF(r, c);
}
TrimColumnWidths();
RemoveBlankSpaceFromRows();
SetupCellUserData();
this.AdjustGridControlSize();
}
public void FixTableCellsHeightWidth()
{
RemoveBlankSpaceFromColumns();
RemoveBlankSpaceFromRows();
}
private void RemoveBlankSpaceFromRows()
{
for (int r = 0; r < Rows.Count; r++)
{
Select(r, 0);
int blankRowSpace = BlankRowSpace();
if (blankRowSpace > 0)
Rows[r].Height -= blankRowSpace;
}
}
private void RemoveBlankSpaceFromColumns()
{
for (int c = 0; c < Cols.Count; c++)
{
Select(0, c);
int blankColSpace = BlankColSpace();
if (blankColSpace > 0)
Cols[c].Width -= blankColSpace;
}
}
private void TrimColumnWidths()
{
for (int c = 0; c < Cols.Count; c++)
{
Select(0, c);
int newColWidth = MinColWidth();
Cols[c].Width = newColWidth;
}
}
private int MinColWidth()
{
int curColWidth = 0;
for (int r = 0; r < Rows.Count; r++)
{
CellRange cr = GetMergedRange(r, Col);
// find the needed cell width
if (Col == cr.c1)
{
using (StepRTB srtb = new StepRTB())
{
srtb.Rtf = GetCellRTFString(cr.r1, cr.c1);
srtb.AdjustWidthForContent();
curColWidth = Math.Max(curColWidth, srtb.Width + 3);
}
}
}
return curColWidth;
}
//private bool RemoveBoldUlineItalicChars(string str)
//{
// int rtn = 0;
// // Underline next word
// rtn += str.IndexOf(@"\'17");
// // Bold next word
// rtn += str.IndexOf(@"\'13");
// // Italics On
// rtn += str.IndexOf(@"\'1B4");
// // Italics Off
// rtn += str.IndexOf(@"\'1B5");
// // underline On
// rtn += str.IndexOf(@"\'ab");
// // underline Off
// rtn += str.IndexOf(@"\'bb");
// return rtn > 0;
//}
private string ConvertTableText(string str)
{
string rtn = str;
//ShowRawString(str, "ConvertTableText IN");
rtn = rtn.Replace(@"START]\v0", @"START]\cf1\v0");
rtn = rtn.Replace(@"\v #Link:", @"\cf0\v #Link:");
rtn = rtn.Replace("\n", "\\par\r\n");
rtn = rtn.Replace("\xB3", @"\f1\u9474?\f0"); // Vert Bar
rtn = rtn.Replace("\xF2", @"\f1\u8805?\f0 "); // greater than or equal
rtn = rtn.Replace("\x7F", @"\f1\u916?\f0 "); // delta
rtn = rtn.Replace("\xF3", @"\f1\u8804?\f0 "); // less than or equal
rtn = rtn.Replace("\xE4", @"\f1\u931?\f0 "); // sigma
rtn = rtn.Replace("\xE7", @"\f1\u947?\f0 "); // gamma
rtn = rtn.Replace("\xFE", @"\f1\u9604?\f0 "); // accum 2584
rtn = rtn.Replace("\x7", @"\f1\u9679?\f0 "); // bullet 25CF
rtn = rtn.Replace("\xF7", @"\f1\u8776?\f0 "); // approx eq
rtn = rtn.Replace("\xF0", @"\f1\u8773?\f0 "); // similar eq 2245
rtn = rtn.Replace("\xFB", @"\f1\u8730?\f0 "); // square root
rtn = rtn.Replace("\xE2", @"\f1\u961?\f0 "); // rho 3C1
rtn = rtn.Replace("\xE3", @"\f1\u960?\f0 "); // pi
rtn = rtn.Replace("\xE6", @"\f1\u956?\f0 "); // micro
rtn = rtn.Replace("\xEB", @"\f1\u948?\f0 "); // lower case delta
rtn = rtn.Replace("\xE5", @"\f1\u963?\f0 "); // lower case sigma
rtn = rtn.Replace("\x90", @"\f1\u274?\f0 "); // energy, 112
rtn = rtn.Replace("\xEE", @"\f1\u949?\f0 "); // epsilon
rtn = rtn.Replace("\xE9", @"\f1\u952?\f0 "); // theta, 3B8
rtn = rtn.Replace("\xEC", @"\f1\u8857?\f0 "); // dot in oval, 2299
rtn = rtn.Replace("\xA8", @"\f1\u964?\f0 "); // tau, 3C4
rtn = rtn.Replace("\xA9", @"\f1\u9830?\f0 "); // diamond, 2666
rtn = rtn.Replace("\x18", @"\f1\u8593?\f0 "); // Up Arrow
rtn = rtn.Replace("\x19", @"\f1\u8595?\f0 "); // Down Arrow
rtn = rtn.Replace("\xFF", @"\u160?"); // hardspace
//rtn = rtn.Replace(@"\'a0", @"\u160?");
//rtn = rtn.Replace("\xff", @"\u160?");
//rtn = rtn.Replace("\xA0", @"\u160?");
// underline On
rtn = rtn.Replace("\xab", @"\ul");
// underline Off
rtn = rtn.Replace("\xbb", @"\ulnone");
//rtn = rtn.Replace("\xef\xe6", @"\up2 ");
//rtn = rtn.Replace("\xef\xe7", @"\up0 ");
rtn = rtn.Replace("\x9566", @"\up2 ");
rtn = rtn.Replace("\x9567", @"\up0 ");
rtn = rtn.Replace("{", @"\{");
rtn = rtn.Replace("}", @"\}");
rtn = rtn.Replace("\xd5", @"\b");
rtn = rtn.Replace("\xd6", @"\b0");
//ShowRawString(rtn, "ConvertTableText OUT");
return rtn;
}
private static string SomethingNextWord(string str, string nxtwordcmd, string cmdOn, string cmdOff)
{
string rtn = "";
int bidx = 0;
int fidx = str.IndexOf(nxtwordcmd, bidx);
char[] term = " \r\n\x02".ToCharArray();
while (fidx > 0)
{
rtn += str.Substring(bidx, fidx - bidx) + cmdOn;
bidx = fidx + 4;
if (bidx < str.Length)
{
fidx = str.IndexOfAny(term, bidx);
if (fidx > 0)
{
rtn += str.Substring(bidx, fidx - bidx) + cmdOff + str.Substring(fidx, 1);
bidx = fidx + 1;
}
}
if (bidx < str.Length)
fidx = str.IndexOf(nxtwordcmd, bidx);
else
fidx = -1;
}
if (bidx < str.Length)
rtn += str.Substring(bidx);
return rtn;
}
private void _StartEdit(object sender, C1.Win.C1FlexGrid.RowColEventArgs e)
{
// start editing the cell with the custom editor
_tableCellEditor.StartEditing(e.Row, e.Col);
e.Cancel = true;
}
// after edit handler (built-in editors)
private void _AfterEdit(object sender, C1.Win.C1FlexGrid.RowColEventArgs e)
{
this.GetCellRange(e.Row, e.Col).Style.ForeColor = Color.Black;
this.AdjustGridControlSize();
}
// if the custom editor is visible, make it follow the cell being edited
private void _AfterScroll(object sender, C1.Win.C1FlexGrid.RangeEventArgs e)
{
this._tableCellEditor.UpdatePosition();
}
// save last key pressed for the custom editor
private void _KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
{
this._tableCellEditor.SetPendingKey(e.KeyChar);
}
public string GetCellRTFString(int row, int col)
{
string rtnstr = "";
foreach (CellRange r in this.MergedRanges)
{
if (r.ContainsRow(row) && r.ContainsCol(col))
{
rtnstr = (string)this[r.r1, r.c1];
return rtnstr;
}
}
rtnstr = (string)this[row, col];
return rtnstr;
}
public void PutCellRTFString(int row, int col, string str)
{
foreach (CellRange r in this.MergedRanges)
{
if (r.ContainsRow(row) && r.ContainsCol(col))
{
this[r.r1, r.c1] = str;
return;
}
}
this[row, col] = str;
return;
}
public void ClearSelectedCellText()
{
CellRange cr = this.Selection;
cr.Clear(ClearFlags.Content);
}
public void SetupCellUserData()
{
for (int r = 0; r < Rows.Count; r++)
for (int c = 0; c < Cols.Count; c++)
{
string rtfText = GetDataDisplay(r, c);
if (rtfText.StartsWith(@"{\rtf"))
{
using (StepRTB _rtf = new StepRTB())
{
_rtf.Width = Cols[c].Width;
_rtf.Rtf = rtfText;
CellRange cr = GetCellRange(r, c);
cr.UserData = _rtf.ContentsRectangle.Height;
}
}
}
}
#endregion //Cell Text
#region Merged / Split Range
public void MergeSelection()
{
this.MergedRanges.Add(this.Selection,true);
this.Invalidate();
this.Select(Selection.r1, Selection.c1);
}
public bool IsInMergeRange()
{
C1.Win.C1FlexGrid.CellRange sel = GetMergedRange(this.Selection.r1, this.Selection.c1);
return MergedRanges.Contains(sel);
}
public void SplitSelection(bool bSplitCols)
{
//Console.WriteLine("SplitSelection this.selection {0}", this.Selection);
//Debug_WritelineMySelection();
//C1.Win.C1FlexGrid.CellRange sel = this.GetMergedRange(this.Selection.r1, this.Selection.c1);
//Console.WriteLine("SplitSelection myselection {0}", MySelection);
//foreach (CellRange sel in MySelection)
//{
// //Console.WriteLine("SplitSelection foreach sel {0}", sel);
// if (sel.IsSingleCell)
// this.MergedRanges.Remove(sel);
// if (!(this.MergedRanges.Contains(sel)) && !didit)
// if (bSplitCols)
// SplitSelectionColumns();
// else
// SplitSelectionRows();
// didit = true;
//}
if (bSplitCols)
SplitSelectionColumns();
else
SplitSelectionRows();
//Debug_WritelineMySelection();
//foreach (CellRange sel in MySelection)
//{
// //Console.WriteLine("SplitSelection foreach sel {0}", sel);
// if (this.MergedRanges.Contains(sel))
// SplitMergedRange(sel, bSplitCols);
//}
//this.Refresh();
//RefreshMergeRangeCollection();
this.AdjustGridControlSize();
}
private void SplitMergedRange(CellRange sel, bool bSplitCols)
{
int sR = sel.r1;
int eR = sel.r2;
int sC = sel.c1;
int eC = sel.c2;
if (bSplitCols && (IsMergedCols(sel) && !IsMergedRows(sel)) ||
(!bSplitCols && (IsMergedRows(sel) && !IsMergedCols(sel))))
MergedRanges.Remove(sel);
else
{
CellRange saveSelection = Selection;
if (bSplitCols && IsMergedRows(sel))
{
MergedRanges.Remove(sel);
for (int c = sC; c <= eC; c++)
{
Select(sR, c, eR, c);
MergeSelection();
}
}
else if (!bSplitCols && IsMergedCols(sel))
{
MergedRanges.Remove(sel);
for (int r = sR; r <= eR; r++)
{
Select(r, sC, r, eC);
MergeSelection();
}
}
Select(saveSelection);
}
}
private bool IsMergedRows(CellRange sel)
{
return (sel.r1 != sel.r2);
}
private bool IsMergedCols(CellRange sel)
{
return (sel.c1 != sel.c2);
}
private void SplitSelectionColumns()
{
bool hasNonMergedColumn = false;
//Console.WriteLine("SplitSelectionColumns this.selection {0}", this.Selection);
//Debug_WritelineMySelection();
CellRange cr = this.Selection;
int numSelCols = (cr.c2 - cr.c1) + 1;
foreach (CellRange sel in MySelection)
{
if (!this.MergedRanges.Contains(sel))
hasNonMergedColumn = true;
else
{
CellRange mr = GetMergedRange(sel.r1, sel.c1);
if (mr.c1 == mr.c2)
hasNonMergedColumn = true;
}
}
// for each column in the selection, add a new column
if (hasNonMergedColumn)
{
for (int c = cr.c2; c >= cr.c1; c--)
{
Select(cr.r1, c, cr.r2, c);
InsertColumnAfter();
}
}
// include new columns in selection
this.Select(cr.r1, cr.c1, cr.r2, cr.c2 + ((hasNonMergedColumn) ? numSelCols : 0));
//if a merged range is part of the selectin, try to split it
foreach (CellRange sel in MySelection)
{
//Console.WriteLine("SplitSelection foreach sel {0}", sel);
if (this.MergedRanges.Contains(sel))
SplitMergedRange(sel, true);
}
cr = this.Selection;
if (hasNonMergedColumn)
{
for (int r = 0; r < this.Rows.Count; r++)
for (int c = cr.c1; c <= cr.c2; c += 2)
{
if (!this.IsCellSelected(r, c))
{
CellRange crTmp = GetMergedRange(r, c);
if (crTmp.IsSingleCell)
{
CellRange tcr = this.GetCellRange(r, c, r, c + 1);
this.MergedRanges.Add(tcr);
this.Invalidate();
}
//CellRange tcr = this.GetCellRange(r, c, r, c + 1);
//this.MergedRanges.Add(tcr);
}
}
// Adjust selected column widths
for (int c = cr.c1; c <= cr.c2; c++)
{
int recWidth = (Cols[c].Width < 0) ? Cols.DefaultSize : Cols[c].Width; // this.GetCellRect(cr.r1, c).Width;
int newWidth = Math.Max(recWidth / 2, _minColSplitWidth);
this.Cols[c].Width = newWidth;
//Console.WriteLine("Cell[{0},{1}].Width = {2}", cr.r1, c, recWidth);
//Console.WriteLine("Cell[{0},{1}].NewWidth = {2}", cr.r1, c, newWidth);
}
}
}
private void SplitSelectionRows()
{
bool hasNonMergedRow = false;
CellRange cr = this.Selection;
int numSelRows = (cr.r2 - cr.r1) + 1;
//Console.WriteLine("numSelRows = {0}", numSelRows);
//Console.WriteLine("Inital Selection [{0},{1}] - [{2},{3}]", cr.r1, cr.c1, cr.r2, cr.c2);
foreach (CellRange sel in MySelection)
{
if (!this.MergedRanges.Contains(sel))
hasNonMergedRow = true;
else
{
CellRange mr = GetMergedRange(sel.r1, sel.c1);
if (mr.r1 == mr.r2)
hasNonMergedRow = true;
}
}
// for each row in the selection, add a new row
if (hasNonMergedRow)
{
for (int r = cr.r2; r >= cr.r1; r--)
{
//Console.WriteLine("Inserted new Row at [{0},{1}]", r, cr.c1);
Select(r, cr.c1, r, cr.c2);
InsertRowAfter();
}
}
// include new rows in selection
this.Select(cr.r1, cr.c1, cr.r2 + numSelRows, cr.c2);
//if a merged range is part of the selectin, try to split it
foreach (CellRange sel in MySelection)
{
//Console.WriteLine("SplitSelection foreach sel {0}", sel);
if (this.MergedRanges.Contains(sel))
SplitMergedRange(sel, false);
}
cr = this.Selection;
//Console.WriteLine(" After Insert [{0},{1}] - [{2},{3}]", cr.r1, cr.c1, cr.r2, cr.c2);
if (hasNonMergedRow)
{
for (int c = 0; c < this.Cols.Count; c++)
for (int r = cr.r1; r <= cr.r2; r += 2)
{
if (!this.IsCellSelected(r, c))
{
CellRange crTmp = GetMergedRange(r, c);
if (crTmp.IsSingleCell)
{
CellRange tcr = this.GetCellRange(r, c, r + 1, c);
this.MergedRanges.Add(tcr);
this.Invalidate();
}
}
}
// Adjust selected Row Heights
for (int r = cr.r1; r <= cr.r2; r++)
{
int recHeight = this.GetCellRect(r, cr.c1).Height;
this.Rows[r].Height = Math.Max(recHeight / 2, Rows.DefaultSize);
//this.Rows[r].Height = Math.Max(recHeight / 2, _minRowSplitHeight);
//Console.WriteLine("Cell[{0},{1}].Height = {2}", r, cr.c1, recHeight);
}
}
//foreach (CellRange crng in this.MergedRanges)
// Console.WriteLine("merge ranges [{0},{1}] - [{2},{3}]", crng.r1, crng.c1, crng.r2, crng.c2);
}
private void AdjustMergedRows(int row, bool above, bool removing)
{
AdjustMergedRows(row, 1, above, removing);
}
private void AdjustMergedRows(int row, int cnt, bool above, bool removing)
{
CellRangeCollection crc = new CellRangeCollection(this);
if (removing)
{
foreach (CellRange r in this.MergedRanges)
{
CellRange cr = r;
if (r.ContainsRow(row))
{
if (r.TopRow != r.BottomRow)
{
cr.r2 -= cnt;
crc.Add(cr);
}
}
else
{
if (row <= r.r1)
{
if (row < r.r1)
cr.r1 -= cnt;
cr.r2 -= cnt;
}
crc.Add(cr);
}
}
}
else // adding
foreach (CellRange r in this.MergedRanges)
{
CellRange cr = r;
int inspos = (above) ? row : row - 1;
if (r.ContainsRow(inspos))
{
bool adjustMergeValues = true;
if (cr.r1 == row && cr.r2 == row + cnt -1)
adjustMergeValues = false; // don't add to existing merge range - we will add a new merge range for this copy
for (int insCnt = 0; insCnt < cnt; insCnt++)
{
if ((above && cr.r1 == inspos) || (!above && cr.r2 == inspos))
{
string tstr = "";
int newrow = 0;
if (above)
{
if (this[cr.r1 + cnt, cr.c1] != null)
tstr = this[cr.r1 + cnt, cr.c1].ToString();
newrow = cr.r1;
}
else
{
if (this[cr.r2, cr.c1] != null)
tstr = this[cr.r2, cr.c1].ToString();
newrow = cr.r2 + cnt;
}
if (tstr != null && tstr.Length > 0)
for (int x = cr.c1; x <= cr.c2; x++)
this[newrow, x] = tstr;
}
if (adjustMergeValues) cr.r2++;
}
}
else
{
if (inspos < cr.r1)
{
cr.r1 += cnt;
cr.r2 += cnt;
}
}
crc.Add(cr);
}
this.MergedRanges.Clear();
foreach (CellRange r in crc)
{
if ((r.r1 != r.r2) || (r.c1 != r.c2))
this.MergedRanges.Add(r);
}
}
private void AdjustMergedColumns(int col, bool left, bool removing)
{
AdjustMergedColumns(col, 1, left, removing); //adjusting for just one column
}
private void AdjustMergedColumns(int col, int cnt, bool left, bool removing)
{
CellRangeCollection crc = new CellRangeCollection(this);
if (removing)
{
foreach (CellRange r in this.MergedRanges)
{
CellRange cr = r;
if (r.ContainsCol(col))
{
if (r.LeftCol != r.RightCol)
{
cr.c2 -= cnt;
crc.Add(cr);
}
}
else
{
if (col < cr.c1)
{
cr.c1-=cnt;
cr.c2-=cnt; }
crc.Add(cr);
}
}
}
else // adding
foreach (CellRange r in this.MergedRanges)
{
CellRange cr = r;
int inspos = (left) ? col : col - 1;
if (r.ContainsCol(inspos))
{
for (int insCnt = 0; insCnt < cnt; insCnt++)
{
string tstr = "";
int newcol = 0;
if (left)
{
if (inspos == cr.c1)
tstr = (this[cr.r1, cr.c1 + 1] == null) ? "" : this[cr.r1, cr.c1 + 1].ToString();
else
tstr = (this[cr.r1, cr.c1] == null) ? "" : this[cr.r1, cr.c1].ToString();
newcol = cr.c1;
}
else
{
if (this[cr.r1, cr.c2] != null)
tstr = this[cr.r1, cr.c2].ToString();
newcol = cr.c2 + 1;
}
for (int x = cr.r1; x <= cr.r2; x++)
this[x, newcol] = tstr;
cr.c2++;
}
}
else if (col <= r.c1)
{
cr.c1+=cnt;
cr.c2+=cnt;
}
crc.Add(cr);
}
this.MergedRanges.Clear();
foreach (CellRange r in crc)
{
if ((r.r1 != r.r2) || (r.c1 != r.c2))
this.MergedRanges.Add(r);
}
}
private bool RowIsInMergeRange(int row)
{
bool rtn = false;
if (row >= 0)
{
CellRange cr = this.Selection;
rtn = true;
int c = cr.c1;
while (rtn && (c <= cr.c2))
{
int idx = this.MergedRanges.IndexOf(row, c);
rtn = (idx > -1);
c++;
}
}
return rtn;
}
private bool ColIsInMergeRange(int col)
{
bool rtn = false;
if (col >= 0)
{
CellRange cr = this.Selection;
//rtn = true;
int r = cr.r1;
while (!rtn && (r <= cr.r2))
{
int idx = this.MergedRanges.IndexOf(col, r);
rtn = (idx > -1);
r++;
}
}
return rtn;
}
#endregion //Merged / Split Range
#region Grid Add and Remove Row / Column
private int GetRowInsertPosition(Boolean before)
{
int rtnrow;
CellRange selcr = this.Selection;
CellRange cr = selcr;
int idx = this.MergedRanges.IndexOf(cr.r1, cr.c2);
if (idx > -1)
cr = this.MergedRanges[idx]; // we want first or last row in merge range
rtnrow = (before) ? cr.r1 : cr.r2;
// The following is an adjustment needed when we are copying an entire row that includes some merged cells
if (selcr.c1 != selcr.c2)
{
while (!before && rtnrow > selcr.r2) rtnrow--;
while (before && rtnrow < selcr.r2) rtnrow++;
}
return rtnrow;
}
private int GetColInsertPosition(Boolean before)
{
int rtncol;
CellRange selcr = this.Selection;
CellRange cr = selcr;
int idx = this.MergedRanges.IndexOf(cr.r1, cr.c2);
if (idx > -1)
cr = this.MergedRanges[idx]; // we want the first of last col in merge range
rtncol = (before) ? cr.c1 : cr.c2;
// The following is an adjustment needed when we are copying an entire column that includes some merged cells
if (selcr.r1 != selcr.r2)
{
while (!before && rtncol > selcr.c2) rtncol--;
while (before && rtncol < selcr.c2) rtncol++;
}
return rtncol;
}
public void InsertColumnBefore()
{
int newcol = this.GetColInsertPosition(true);
this.Cols.Insert(newcol);
// set new column width to same width as column from where it was inserted
this.Cols[newcol].Width = this.Cols[newcol + 1].Width;
MyBorders.InsertColumn(newcol);
this.AdjustMergedColumns(newcol, true, false);
this.AdjustGridControlSize();
}
public void InsertColumnAfter()
{
int colidx = this.GetColInsertPosition(false);
if (colidx == this.Cols.Count - 1) // last column
this.Cols.Add(1);
else
this.Cols.Insert(colidx + 1);
MyBorders.InsertColumn(colidx);
// set new column width to same width as column from where it was inserted
this.Cols[colidx + 1].Width = this.Cols[colidx].Width;
this.AdjustMergedColumns(colidx + 1, false, false);
this.AdjustGridControlSize();
}
public void InsertRowBefore()
{
int newrow = this.GetRowInsertPosition(true);
this.Rows.Insert(newrow);
// set new row Height to same heidht as row from where it was inserted
this.Rows[newrow].Height = (Rows[newrow + 1].Height == -1) ? Rows.DefaultSize : Rows[newrow + 1].Height;
//this.Rows[newrow].Height = this.Rows[newrow + 1].Height;
MyBorders.InsertRow(newrow);
this.AdjustMergedRows(newrow, true, false);
this.AdjustGridControlSize();
}
public void InsertRowAfter()
{
int rowidx = this.GetRowInsertPosition(false);
if (rowidx == this.Rows.Count - 1) // last row
this.Rows.Add(1);
else
this.Rows.Insert(rowidx + 1);
// set new row Height to same heidht as row from where it was inserted
this.Rows[rowidx + 1].Height = (Rows[rowidx].Height == -1) ? Rows.DefaultSize : Rows[rowidx].Height;
//this.Rows[rowidx + 1].Height = this.Rows[rowidx].Height;
MyBorders.InsertRow(rowidx + 1);
this.AdjustMergedRows(rowidx + 1, false, false);
this.AdjustGridControlSize();
}
public bool AllRowsSelected()
{
int maxrow = Selection.r2;
foreach (CellRange cr in MySelection)
maxrow = Math.Max(maxrow, cr.r2);
return (Selection.r1 == 0 && maxrow == Rows.Count - 1);
}
public bool AllColumnsSelected()
{
int maxcol = Selection.c2;
foreach (CellRange cr in MySelection)
maxcol = Math.Max(maxcol, cr.c2);
return (Selection.c1 == 0 && maxcol == Cols.Count - 1);
}
public void RemoveSelectedColumn()
{
string msg = "";
string title = "";
CellRange saveCR = Selection;
this.SelectionMode = SelectionModeEnum.ColumnRange;
//this.Select(this.Selection.r1, this.Selection.c1);
this.Select(0, Selection.c1, Rows.Count - 1, Selection.c2);
this.SelectionMode = SelectionModeEnum.Default;
if (Selection.c1 != Selection.c2)
{
msg = "Remove selected columns?";
title = "Delete Columns";
}
else
{
msg = "Remove this column?";
title = "Delete Column";
}
DialogResult dr = MessageBox.Show(msg, title, MessageBoxButtons.YesNo);
if (dr == DialogResult.Yes)
RemoveSelectedCells();//RemoveColumns(this.Selection.r1, this.Selection.c1, 1);
else
Select(saveCR);
}
public void RemoveSelectedRow()
{
string msg = "";
string title = "";
CellRange saveCR = Selection;
this.SelectionMode = SelectionModeEnum.RowRange;
//this.Select(this.Selection.r1, this.Selection.c1,);
this.Select(Selection.r1, 0, Selection.r2, Cols.Count - 1);
this.SelectionMode = SelectionModeEnum.Default;
if (Selection.r1 != Selection.r2)
{
msg = "Remove selected rows?";
title = "Delete Rows";
}
else
{
msg = "Remove this row?";
title = "Delete Row";
}
DialogResult dr = MessageBox.Show(msg, title, MessageBoxButtons.YesNo);
if (dr == DialogResult.Yes)
this.RemoveSelectedCells();//this.RemoveRows(this.Selection.r1, this.Selection.c1, 1);
else
Select(saveCR);
}
private void RemoveRows(int strow, int stcol, int cnt)
{
bool mergedRow = false;
for (int i = 0; i < cnt; i++)
{
//if (this.RowIsInMergeRange(strow))
//{
for (int cl = 0; cl < this.Cols.Count && !mergedRow; cl++)
{
int idx = this.MergedRanges.IndexOf(strow, cl);
if (idx > -1)
{
CellRange cr = this.MergedRanges[idx];
if (cr.r1 < cr.r2)
mergedRow = true;
//this[cr.r1 + 1, cr.c1] = this[cr.r1, cr.c1];
}
cl++;
}
//}
this.Rows.Remove(strow);
this.AdjustMergedRows(strow, false, true);
//if (mergedRow)
//{
//cnt++;
mergedRow = false;
//}
}
MyBorders.DeleteRows(strow, cnt);
this.AdjustGridControlSize();
}
private void RemoveColumns(int strow, int stcol, int cnt)
{
bool mergedCol = false;
for (int i = 0; i < cnt; i++)
{
//if (this.ColIsInMergeRange(stcol))
//{
for (int rw = 0; rw < this.Rows.Count && !mergedCol; rw++)
{
int idx = this.MergedRanges.IndexOf(rw, stcol);
if (idx > -1)
{
CellRange cr = this.MergedRanges[idx];
if (cr.c1 < cr.c2)
mergedCol = true;
//this[cr.r1, cr.c1 + 1] = this[cr.r1, cr.c1];
}
}
//}
this.Cols.Remove(stcol);
this.AdjustMergedColumns(stcol, false, true);
//if (mergedCol)
//{
// //cnt++;
mergedCol = false;
//}
}
MyBorders.DeleteColumns(stcol, cnt);
this.AdjustGridControlSize();
}
public void RemoveSelectedCells()
{
bool didremove = false;
int lastRow = this.Rows.Count - 1;
int lastCol = this.Cols.Count - 1;
CellRange cr = this.Selection;
// r2 is last row (or in merge range containing last row)
// r1 is first row or r1-m (m is in merge range) is first row
// we can remove columns c1 through c2
int idx = this.MergedRanges.IndexOf(cr.r2, cr.c2);
CellRange mr = new CellRange();
if (idx > -1) mr = this.MergedRanges[idx];
if (cr.r2 == lastRow || idx > -1 && mr.r2 == lastRow)//RowIsInMergeRange(grd,cr.r2))
{
if (cr.r1 == 0 || this.RowIsInMergeRange(cr.r1 - 1))
{
this.RemoveColumns(cr.r1, cr.c1, cr.RightCol - cr.LeftCol + 1);// remove selected columns
didremove = true;
}
}
// c2 is last column (or in merge range containing last column)
// c1 is first column or c1-m (m is merge range) is first column
// we can remove rows r1 through r2
if (cr.c2 == lastCol || idx > -1 && mr.c2 == lastCol)//ColIsInMergeRange(grd,cr.c1-1))
{
if (cr.c1 == 0 || this.ColIsInMergeRange(cr.c1 - 1))
{
// remove selected rows
this.RemoveRows(cr.r1, cr.c1, cr.BottomRow - cr.TopRow + 1);
didremove = true;
}
}
if (!didremove)
MessageBox.Show("Cannot Removed Part of a Row or Column.\n\nNote: This function allows you to delete one or more rows/columns at time.", "Invalid Selection",MessageBoxButtons.OK,MessageBoxIcon.Hand);
return;
}
#endregion //Grid Add and Remove Row / Column
#region Copy/Paste
public void CopyRow()
{
DialogResult dr = DialogResult.Yes;
SelectRow();
if (Selection.r1 != Selection.r2)
{
//dr = MessageBox.Show("You selected a row that includes merged cells.\n\nThese additional rows must be included.\n\nCopy these rows?", "Copy Rows", MessageBoxButtons.YesNo);
dr = MessageBox.Show("Your selection was expanded due to merged cell regions.\n\nContinue with the copy?", "Copy Rows", MessageBoxButtons.YesNo);
}
if (dr == DialogResult.Yes)
CopyToCopiedFlexGrid(GridCopyOption.Row);
}
public void CopyColumn()
{
SelectCol();
DialogResult dr = DialogResult.Yes;
if (Selection.c1 != Selection.c2)
{
//dr = MessageBox.Show("You selected a column that includes merged cells.\n\nThese additional columns must be included.\n\nCopy these columns?", "Copy Columns", MessageBoxButtons.YesNo);
dr = MessageBox.Show("Your selection was expanded due to merged cell regions.\n\nContinue with the copy?", "Copy Columns", MessageBoxButtons.YesNo);
}
if (dr == DialogResult.Yes)
CopyToCopiedFlexGrid(GridCopyOption.Column);
}
public void CopyCellSelection()
{
DialogResult dr = DialogResult.Yes;
CellRange cr = Selection;
MakeSelectionEven();
if (!cr.Equals(Selection))
{
dr = MessageBox.Show("Your selection was expanded due to merged cell regions.\n\nContinue with the copy?", "Copy Selection", MessageBoxButtons.YesNo);
}
if (dr == DialogResult.Yes)
CopyToCopiedFlexGrid(GridCopyOption.Selection);
}
public enum enmPastePos : int
{
Before = 1, Replace = 0, After = -1
}
public void PasteRows(enmPastePos pp)
{
if (MyCopyInfo.MyCopiedFlexGrid == null || MyCopyInfo.MyCopyOption != GridCopyOption.Row) return;
int rowsToAdd = MyCopyInfo.MyCopiedCellRange.r2 - MyCopyInfo.MyCopiedCellRange.r1 + 1;
int colsToAdd = Math.Max((MyCopyInfo.MyCopiedCellRange.c2 - MyCopyInfo.MyCopiedCellRange.c1 + 1) - Cols.Count, 0);
int selR1 = Selection.r1;
int selR2 = Selection.r2;
int rowOffset = selR1 + (pp == enmPastePos.After ?(selR2-selR1)+1 : 0) - MyCopyInfo.MyCopiedCellRange.r1;
// If the rows we are copying has more columns than the current table, then append then needed columns to the grid
if (colsToAdd > 0)
{
Cols.Add(colsToAdd);
AdjustMergedColumns(Cols.Count - 1, colsToAdd, false, false);
MyBorders.InsertColumns(Cols.Count - colsToAdd - 1, colsToAdd);
}
switch (pp)
{
case enmPastePos.Before:
this.Rows.InsertRange(selR1, rowsToAdd);
AdjustMergedRows(selR1, rowsToAdd, true, false);
MyBorders.InsertRows(Rows.Count - rowsToAdd - 1, rowsToAdd);
break;
case enmPastePos.After:
if (selR2+1 < Rows.Count - 1)
{
this.Rows.InsertRange(selR2 + 1, rowsToAdd);
AdjustMergedRows(selR1+1, rowsToAdd, false, false);
}
else
this.Rows.Add(rowsToAdd);
MyBorders.InsertRows(Rows.Count - rowsToAdd - 1, rowsToAdd);
break;
case enmPastePos.Replace:
if (rowsToAdd > Rows.Count - Selection.r1)
{
int numToAdd = rowsToAdd - (Rows.Count = selR1);
this.Rows.Add(numToAdd);
AdjustMergedRows(selR1, numToAdd, false, false);
}
break;
}
RemoveMergedRanges(MyCopyInfo.MyCopiedCellRange.r1 + rowOffset, MyCopyInfo.MyCopiedCellRange.c1, MyCopyInfo.MyCopiedCellRange.r2 + rowOffset, MyCopyInfo.MyCopiedCellRange.c2);
for (int r = MyCopyInfo.MyCopiedCellRange.r1; r <= MyCopyInfo.MyCopiedCellRange.r2; r++)
{
Rows[r + rowOffset].Height = MyCopyInfo.MyCopiedFlexGrid.Rows[r].Height;
for (int c = MyCopyInfo.MyCopiedCellRange.c1; c <= Math.Min(MyCopyInfo.MyCopiedCellRange.c2 + colsToAdd, Cols.Count - 1); c++)
{
CellRange crm = MyCopyInfo.MyCopiedFlexGrid.GetMergedRange(r, c);
if (r == crm.r1 && c == crm.c1)
{
Cols[c].Width = Math.Max(Cols[c].Width, MyCopyInfo.MyCopiedFlexGrid.Cols[c].Width);
CellRange cr = GetCellRange(crm.r1 + rowOffset, crm.c1, crm.r2 + rowOffset, crm.c2);
// if the paste is above - copy merge range for the destination
// if the paste is below - put back the range for the source location
if ((crm.r2 > crm.r1) || (crm.c2 > crm.c1))
MergedRanges.Add(cr);
this[r + rowOffset, c] = MyCopyInfo.MyCopiedFlexGrid[r, c];
MatchStyle(crm, cr);
PasteBorders(r + rowOffset, c, r, c);
// if the paste is above - put back the range for the source location
// if the paste is below - copy merge range for the destination
int r1 = crm.r1 + rowsToAdd - rowOffset;
int r2 = crm.r2 + rowsToAdd - rowOffset;
CellRange ncr = GetCellRange(r1, crm.c1, r2, crm.c2);
if ((crm.r2 > crm.r1) || (crm.c2 > crm.c1))
MergedRanges.Add(ncr);
}
}
}
this.AdjustGridControlSize();
CopyToCopiedFlexGrid(MyCopyInfo.MyCopyOption);
}
private void MatchStyle(CellRange crm, CellRange cr)
{
if (crm.Style != null)
{
ChangeCellAlign(cr, crm.Style.TextAlign);
ChangeCellBorder(cr, crm.Style.Border.Style);
}
//else
//{
// cr.Style = null; // - didn't like the null
//}
}
private void RemoveMergedRanges(int r1, int c1, int r2, int c2)
{
for (int r = r1; r <= r2; r++)
for (int c = c1; c <= c2; c++)
{
CellRange cr = GetMergedRange(r, c);
if (cr.r1 < cr.r2 || cr.c1 < cr.c2)
MergedRanges.Remove(cr);
}
}
public void PasteColumns(enmPastePos pp)
{
if (MyCopyInfo.MyCopiedFlexGrid == null || MyCopyInfo.MyCopyOption != GridCopyOption.Column) return;
int colsToAdd = MyCopyInfo.MyCopiedCellRange.c2 - MyCopyInfo.MyCopiedCellRange.c1 + 1;
int rowsToAdd = Math.Max((MyCopyInfo.MyCopiedCellRange.r2 - MyCopyInfo.MyCopiedCellRange.r1 + 1) - Rows.Count, 0);
int selC1 = Selection.c1;
int selC2 = Selection.c2;
int colOffset = selC1 + (pp == enmPastePos.After ? (selC2-selC1)+1 : 0) - MyCopyInfo.MyCopiedCellRange.c1;
// If the columns we are copying has more rows than the current table, then append the needed rows to the grid
if (rowsToAdd > 0)
{
Rows.Add(rowsToAdd);
AdjustMergedRows(Rows.Count, false, false);
MyBorders.InsertRows(Rows.Count - rowsToAdd - 1,rowsToAdd);
}
switch (pp)
{
case enmPastePos.Before:
this.Cols.InsertRange(selC1, colsToAdd);
AdjustMergedColumns(selC1, colsToAdd, true, false);
MyBorders.InsertColumns(Cols.Count - colsToAdd - 1, colsToAdd);
break;
case enmPastePos.After:
if (selC2+1 < Cols.Count - 1)
{
this.Cols.InsertRange(selC2+1, colsToAdd);
AdjustMergedColumns(selC1+1, colsToAdd, false, false);
}
else
this.Cols.Add(colsToAdd);
MyBorders.InsertColumns(Cols.Count - colsToAdd - 1, colsToAdd);
break;
case enmPastePos.Replace:
if (colsToAdd > Cols.Count - selC1)
{
int numToAdd = colsToAdd - (Cols.Count - selC1);
this.Cols.Add(numToAdd);
AdjustMergedColumns(selC1, numToAdd, true, false);
}
break;
}
RemoveMergedRanges(MyCopyInfo.MyCopiedCellRange.r1, MyCopyInfo.MyCopiedCellRange.c1 + colOffset, MyCopyInfo.MyCopiedCellRange.r2, MyCopyInfo.MyCopiedCellRange.c2 + colOffset);
// Fix the merge ranges
for (int c = MyCopyInfo.MyCopiedCellRange.c1; c <= MyCopyInfo.MyCopiedCellRange.c2; c++)
{
Cols[c + colOffset].Width = MyCopyInfo.MyCopiedFlexGrid.Cols[c].Width;
for (int r = MyCopyInfo.MyCopiedCellRange.r1; r <= Math.Min(MyCopyInfo.MyCopiedCellRange.r2 + rowsToAdd, Rows.Count - 1); r++)
{
CellRange crm = MyCopyInfo.MyCopiedFlexGrid.GetMergedRange(r, c);
if (r == crm.r1 && c == crm.c1)
{
Rows[r].Height = Math.Max(Rows[r].Height, MyCopyInfo.MyCopiedFlexGrid.Rows[r].Height);
CellRange cr = GetCellRange(crm.r1, crm.c1 + colOffset, crm.r2, crm.c2 + colOffset);
// if the paste is to the left - copy merge range for the destination
// if the paste is to the right - put back the range for the source location
if ((crm.r2 > crm.r1) || (crm.c2 > crm.c1))
MergedRanges.Add(cr);
// copy cell text to the destination, copy the style, copy the cell borders
this[r, c + colOffset] = MyCopyInfo.MyCopiedFlexGrid[r, c];
MatchStyle(crm, cr);
PasteBorders(r, c + colOffset, r, c);
// if the paste is to the left - put back the range for the source location
// if the paste is to the right - copy merge range for the destination
int c1 = crm.c1 + colsToAdd - colOffset;
int c2 = crm.c2 + colsToAdd - colOffset;
CellRange ncr = GetCellRange(crm.r1, c1, crm.r2, c2);
if ((crm.r2 > crm.r1) || (crm.c2 > crm.c1))
MergedRanges.Add(ncr);
}
}
}
this.AdjustGridControlSize();
CopyToCopiedFlexGrid(MyCopyInfo.MyCopyOption);
}
public void PasteCopiedCells()
{
// Warn the user that this type of paste will replace the currently selected (highlighted) table cells and give the option to abort.
DialogResult dr = MessageBox.Show("This will replace the cells that are currently selected (highlighted). \n\nContinue with the paste?","Paste Table Cells",MessageBoxButtons.YesNo,MessageBoxIcon.Question);
if (dr == DialogResult.No) return;
int nSelRows = Selection.r2 - Selection.r1 + 1;
int nSelCols = Selection.c2 - Selection.c1 + 1;
int nCpyRows = MyCopyInfo.MyCopiedCellRange.r2 - MyCopyInfo.MyCopiedCellRange.r1 + 1;
int nCpyCols = MyCopyInfo.MyCopiedCellRange.c2 - MyCopyInfo.MyCopiedCellRange.c1 + 1;
int colsToAdd = Math.Max(nCpyCols - nSelCols, 0);
int rowsToAdd = Math.Max(nCpyRows - nSelRows, 0);
int rowOffset = Selection.r1 - MyCopyInfo.MyCopiedCellRange.r1;
int colOffset = Selection.c1 - MyCopyInfo.MyCopiedCellRange.c1;
int selR2 = Selection.r2;
int selC2 = Selection.c2;
// If there are more cells to copy than what is seleceted in the target table
// Add extra rows and columns as needed
if (rowsToAdd > 0)
{
if (selR2 < Rows.Count - 1)
{
this.Rows.InsertRange(selR2 + 1, rowsToAdd);
AdjustMergedRows(selR2 + 1, false, false);
}
else
this.Rows.Add(rowsToAdd);
MyBorders.InsertRows(selR2,rowsToAdd);
}
if (colsToAdd > 0)
{
if (selC2 < Cols.Count - 1)
{
this.Cols.InsertRange(selC2 + 1, colsToAdd);
AdjustMergedColumns(selC2 + 1, false, false);
}
else
this.Cols.Add(colsToAdd);
MyBorders.InsertColumns(selC2,colsToAdd);
}
RemoveMergedRanges(MyCopyInfo.MyCopiedCellRange.r1 + rowOffset, MyCopyInfo.MyCopiedCellRange.c1 + colOffset, MyCopyInfo.MyCopiedCellRange.r2 + rowOffset, MyCopyInfo.MyCopiedCellRange.c2 + colOffset);
for (int c = MyCopyInfo.MyCopiedCellRange.c1; c <= Math.Min(MyCopyInfo.MyCopiedCellRange.c2, Cols.Count - 1 - colOffset); c++)
Cols[c + colOffset].Width = Math.Max(MyCopyInfo.MyCopiedFlexGrid.Cols[c].Width, Cols[c + colOffset].Width);
for (int r = MyCopyInfo.MyCopiedCellRange.r1; r <= Math.Min(MyCopyInfo.MyCopiedCellRange.r2, Rows.Count - 1 - rowOffset); r++)
{
Rows[r + rowOffset].Height = Math.Max(MyCopyInfo.MyCopiedFlexGrid.Rows[r].Height, Rows[r + rowOffset].Height);
for (int c = MyCopyInfo.MyCopiedCellRange.c1; c <= Math.Min(MyCopyInfo.MyCopiedCellRange.c2, Cols.Count - 1 - colOffset); c++)
{
CellRange crm = MyCopyInfo.MyCopiedFlexGrid.GetMergedRange(r, c);
if (r == crm.r1 && c == crm.c1)
{
CellRange cr = GetCellRange(crm.r1 + rowOffset, crm.c1 + colOffset, crm.r2 + rowOffset, crm.c2 + colOffset);
if ((crm.r2 > crm.r1) || (crm.c2 > crm.c1))
MergedRanges.Add(cr);
this[r + rowOffset, c + colOffset] = MyCopyInfo.MyCopiedFlexGrid[r, c];
MatchStyle(crm, cr);
PasteBorders(r + rowOffset, c + colOffset, r, c);
}
}
}
this.AdjustGridControlSize();
CopyToCopiedFlexGrid(MyCopyInfo.MyCopyOption);
}
#endregion // Copy/Paste
#region Selection
public bool SelectNextCell()
{
int r = this.Row;
int c = this.Col;
CellRange cr = GetMergedRange(r, c);
do
{
c = cr.c2 + 1;
if (c >= this.Cols.Count)
{
r = r + 1;
c = 0;
if (r >= this.Rows.Count) return false;
}
cr = GetMergedRange(r, c);
} while (r != cr.r1 || c != cr.c1);
Select(r, c);
return true;
}
public bool SelectPrevCell()
{
int r = this.Row;
int c = this.Col;
CellRange cr = GetMergedRange(r, c);
do
{
c = cr.c1 - 1;
if (c < 0)
{
r = r - 1;
c = this.Cols.Count-1;
if (r < 0) return false;
}
cr = GetMergedRange(r, c);
c = cr.c1;
} while (r != cr.r1);
Select(r, c);
return true;
}
#endregion
#region SearchableText
public string GetSearchableText()
{
StringBuilder sb = new StringBuilder();
int r = 0;
int c = 0;
int w = Cols.Count;
int h = Rows.Count;
while (r < h)
{
CellRange cr = GetMergedRange(r, c);
if (cr.r1 == r && cr.c1 == c)
{
if (this[r, c] != null)
{
string strp = DisplayText.StaticStripRtfCommands((string)this[r, c]);
sb.Append(strp.Replace("\r\n", " "));
}
sb.Append("\r\n");
}
c = c + 1;
if (c == w)
{
c = 0;
r = r + 1;
}
}
return sb.ToString();
}
#endregion
#region Import / Export Grid
/// <summary>
/// Prompts user with Save File dialog.
/// Grid will be saved to an XML file.
/// </summary>
/// <param name="initDir"></param>
public void ExportToXML(string initDir)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.DefaultExt = ".xml";
sfd.Filter = "XML files (*.xml)|*.xml|All files (*.*)|*.* ";
//sfd.InitialDirectory = @"C:\Development\SampleTableData";
sfd.InitialDirectory = initDir;
sfd.Title = "Save XML File";
sfd.ShowDialog();
this.WriteXml(sfd.FileName);
}
public string GetXMLData()
{
string retstr = null;
using (StringWriter sw = new StringWriter())
{
this.WriteXml(sw);
retstr = sw.GetStringBuilder().ToString();
sw.Close();
}
return retstr;
}
/// <summary>
/// Prompts user with Save File dialog.
/// Grid will be saved to an Excel file.
/// </summary>
/// <param name="initDir"></param>
public void ExportToExcel(string initDir)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.DefaultExt = ".xls";
sfd.Filter = "Excel files (*.xls)|*.xls|All files (*.*)|*.* ";
//sfd.InitialDirectory = @"C:\Development\SampleTableData";
sfd.InitialDirectory = initDir;
sfd.Title = "Save Excel File";
sfd.ShowDialog();
this.SaveExcel(sfd.FileName);
}
/// <summary>
/// Prompts user with Open File dialog.
/// XML file will be imported to a table grid.
/// </summary>
/// <param name="initDir"></param>
/// <returns></returns>
public string ImportXML(string initDir)
{
string rtn = "";
OpenFileDialog ofd = new OpenFileDialog();
ofd.DefaultExt = ".xml";
ofd.Filter = "XML files (*.xml)|*.xml|All files (*.*)|*.* ";
//ofd.InitialDirectory = @"C:\Development\SampleTableData";
ofd.InitialDirectory = initDir;
ofd.Multiselect = false;
ofd.Title = "Select XML File";
ofd.ShowDialog();
this.Clear();
this.MergedRanges.Clear();
this.ReadXml(ofd.FileName);
this.BorderStyle = C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.None;
this.KeyActionTab = KeyActionEnum.MoveAcross;
this.AdjustGridControlSize();
rtn = ofd.SafeFileName;
return rtn;
}
/// <summary>
/// Prompts user with Open File dialog.
/// Excel file will be imported to a table grid.
/// </summary>
/// <param name="initDir"></param>
/// <returns></returns>
public string ImportExcel(string initDir)
{
string rtn = "";
//VlnFlexGrid grd = rbtDefaultTable.Checked ? vlnFlexGrid2 : vlnFlexGrid3; //GetActiveGrid();
OpenFileDialog ofd = new OpenFileDialog();
ofd.DefaultExt = ".xls";
ofd.Filter = "Excel files (*.xls)|*.xls|All files (*.*)|*.*";
//ofd.InitialDirectory = @"C:\Development\SampleTableData";
ofd.InitialDirectory = initDir;
ofd.Multiselect = false;
ofd.Title = "Select Excel File";
ofd.ShowDialog();
this.Clear();
this.MergedRanges.Clear();
this.LoadExcel(ofd.FileName);
this.AdjustGridControlSize();
rtn = ofd.SafeFileName;
return rtn;
}
public void ConvertTableROToGrid(string valtext, int rodbid, string roid)
{
VE_Font vefont = _MyItemInfo.GetItemFont();
this.Font = vefont.WindowsFont;
this.MergedRanges.Clear();
this.Clear();
this.IsRoTable = true;
this.ParseTableFromText(valtext, GridLinePattern.Single);
this.AutoSizeCols();
this.AutoSizeRows();
this.MakeRTFcells();
this.RODbId = rodbid;
this.ROID = roid;
}
private Regex _ReplaceSpaceNewLine = new Regex(@"(?<=\\[^' \\?\r\n\t]*) (?=\r\n)");
private Regex _ReplaceTokenSpaceToken = new Regex(@"(?<=\\[^' \\?\r\n\t]*) (?=\\)");
private Regex _RemoveComments = new Regex(@"\\v .*?\\v0( |$)");
private string PrepROTableText(string stepText)
{
// we need to convert some RTF command to DOS so that we can
// figure out the table size
stepText = stepText.Replace("\r", "");
stepText = stepText.Replace("\xF8", @"\'f8");
stepText = stepText.Replace(@"\par ", "\r\n");
stepText = _ReplaceTokenSpaceToken.Replace(stepText, "");
//Change Token Order to match RTB output
stepText = stepText.Replace(@"\v0\b0", @"\b0\v0");
stepText = stepText.Replace(@"\b0\ulnone", @"\ulnone\b0");
stepText = _ReplaceSpaceNewLine.Replace(stepText, "");
// Now change the Unicode symbols to DOS symbols
stepText = stepText.Replace(@"\u8209?", "-");
stepText = stepText.Replace(@"\u9474?", "\xB3"); // Vert Line graphic character
stepText = stepText.Replace(@"\'b0", "\xB0");
stepText = stepText.Replace(@"\up2 ", "\x9566");
stepText = stepText.Replace(@"\up0 ", "\x9567");
stepText = stepText.Replace(@"\ulnone", "\xBB");
stepText = stepText.Replace(@"\ul", "\xAB");
stepText = stepText.Replace(@"\{", "{");
stepText = stepText.Replace(@"\}", "}");
stepText = stepText.Replace(@"\b0", "\xD6");
stepText = stepText.Replace(@"\b", "\xD5");
stepText = stepText.Replace(@"\u160?", "\xA0"); //hard space
stepText = stepText.Replace(@"\u916?", "\x7F"); // delta
stepText = stepText.Replace(@"\u8805?", "\xF2"); //greater than or equal
stepText = stepText.Replace(@"\u8804?", "\xF3"); // less than or equal
stepText = stepText.Replace(@"\u931?", "\xE4"); // sigma
stepText = stepText.Replace(@"\u947?", "\xE7"); // gamma
stepText = stepText.Replace(@"\u9604?", "\xFE"); // accum 2584
stepText = stepText.Replace(@"\u9679?", "\x7"); // bullet 25CF
stepText = stepText.Replace(@"\u8776?", "\xF7"); // approx eq
stepText = stepText.Replace(@"\u8773?", "\xF0"); // similar eq 2245
stepText = stepText.Replace(@"\u8730?", "\xFB"); // square root
stepText = stepText.Replace(@"\u961?", "\xE2"); // rho 3C1
stepText = stepText.Replace(@"\u960?", "\xE3"); // pi
stepText = stepText.Replace(@"\u956?", "\xE6"); // micro
stepText = stepText.Replace(@"\u948?", "\xEB"); // lower case delta
stepText = stepText.Replace(@"\u963?", "\xE5"); // lower case sigma
stepText = stepText.Replace(@"\u274?", "\x90"); // energy, 112
stepText = stepText.Replace(@"\u949?", "\xEE"); // epsilon
stepText = stepText.Replace(@"\u952?", "\xE9"); // theta, 3B8
stepText = stepText.Replace(@"\u8857?", "\xEC"); // dot in oval, 2299
stepText = stepText.Replace(@"\u964?", "\xA8"); // tau, 3C4
stepText = stepText.Replace(@"\u9830?", "\xA9"); // diamond, 2666
stepText = stepText.Replace(@"\u8593?", "\x18"); // Up Arrow - changes to \xff
stepText = stepText.Replace(@"\u8595?", "\x19"); // Down Arrow - changes to \xd6
// Fix "|" followed by a newline - this confuses the table converter
stepText = stepText.Replace(@"|\r\n", @"| \r\n");
stepText = stepText.Replace(@"|\n\r", @"| \n\r");
stepText = stepText.Replace(@"|\n", @"| \n");
// if the entire row is underlined, then remove the underline and insert a row of dashes
stepText = ConvertUnderlineToRow(stepText);
return stepText;
}
private bool IsPrintableTableChar(char c)
{
string printablSymbols = "\xB3\xA0\x7F\xF2\xF3\xE4\xE7\xFE\x07\xF7\xF0\xFB\xE2\xE3\xE6\xEB\xE5\x90\xEE\xE9\xEC\xA8\xA9\x18\x19";
return (((c > '\x1F') && (c < '\x80')) || (printablSymbols.IndexOf(c) >= 0));
}
private string ConvertUnderlineToRow(string stepText)
{
string rtnStr = "";
char[] sep = { '\n' };
string[] lines = stepText.Split(sep);
foreach (string line in lines)
{
int idx = 0;
int chrCnt = 0;
int uOnPos = -1;
int uOffPos = -1;
bool ulineOn = false;
char curChar = line[idx];
string dashRow = "";
while (idx < line.Length && !IsPrintableTableChar(line[idx]))
{
if (line[idx] == '\xAB') //underline ON
{
ulineOn = true;
uOnPos = idx;
}
idx++;
}
while (ulineOn && idx < line.Length)
{
if (IsPrintableTableChar(line[idx]))
{
if (line[idx] == '|' || line[idx] == '\xB3')
{
dashRow += new string('-', chrCnt);
dashRow += "|";
chrCnt = 0;
}
else
chrCnt++;
idx++;
}
else
{
if (line[idx] == '\xBB') //underline OFF
{
uOffPos = idx;
ulineOn = false;
while ((idx < line.Length) && !IsPrintableTableChar(line[idx]))
{
if (line[idx] == '\xAB')
ulineOn = true;
idx++;
}
if (idx == line.Length)
ulineOn = true;
if (!ulineOn)
dashRow = "";
}
else
idx++;
}
}
string curLine = line;
curLine = curLine.Replace('\xB3', '|'); // replace graphic vert bar with DOS vert bar
if (ulineOn && idx == line.Length) // entire line is underlined, remove underline, insert row of dashes
{
curLine = curLine.Replace("\xAB", ""); // remove Underline ON
curLine = curLine.Replace("\xBB", ""); // remove Underline OFF
dashRow += new string('-', chrCnt);
dashRow = "\n" + dashRow;
}
if (rtnStr.Length > 0) rtnStr += "\n";
rtnStr += curLine;
rtnStr += dashRow;
}
return rtnStr;
}
/// <summary>
/// This will parse a string containing the ascii text of the old style VE-PROMS (16-bit) tables.
/// It will find the number of rows and columns base on newlines, vertical bars, and dashes.
/// Then it will parse the the text, place them in cells, and attempt to merge cells were needed.
/// </summary>
/// <param name="txtbuff"></param>
public void ParseTableFromText(string buff,GridLinePattern border)
{
string txtbuff = PrepROTableText(buff);
if (IsRoTable) txtbuff = _RemoveComments.Replace(txtbuff, "");
int curRow = 0;
int curCol = 0;
int maxRow = 0;
int maxCol = 0;
// Get Max Rows and Max Cols
char[] test = "|\n\x02".ToCharArray();
int idx = 0;
int idxst = 0;
int colPos = 0;
int strow = 0;
Dictionary<int, int> dicCols = new Dictionary<int, int>();
do
{
idx = txtbuff.IndexOfAny(test, idxst);
if (idx > -1)
{
switch (txtbuff[idx])
{
case '|': // end of a column
colPos = idxst - strow;
if (!dicCols.ContainsKey(colPos))
dicCols.Add(colPos, curCol);
else if (curCol > dicCols[colPos])
{
dicCols.Remove(colPos);
dicCols.Add(colPos, curCol);
}
curCol++;
break;
case '\x02':
case '\n': // end of a row
colPos = idxst - strow;
if (!dicCols.ContainsKey(colPos))
dicCols.Add(colPos, curCol);
else if (curCol > dicCols[colPos])
{
dicCols.Remove(colPos);
dicCols.Add(colPos, curCol);
}
curRow++;
strow = idx + 1;
if (curCol > maxCol)
maxCol = curCol;
curCol = 0;
break;
}
idxst = idx + 1;
if (idxst >= txtbuff.Length)
idx = -1;
}
} while (idx != -1);
if (idxst < txtbuff.Length)
{
colPos = idxst - strow;
if (!dicCols.ContainsKey(colPos))
dicCols.Add(colPos, curCol);
else if (curCol > dicCols[colPos])
{
dicCols.Remove(colPos);
dicCols.Add(colPos, curCol);
}
}
maxRow = curRow; // +1;
curRow = 0;
curCol = 0;
// The resulting Table Grid size in rows and columns
this.Cols.Count = maxCol + 1;
this.Rows.Count = maxRow + 1;
// make all rows and columns editable
this.Rows.Fixed = 0;
this.Cols.Fixed = 0;
// TableCellInfo is used to assign merge ranges
// Make a two dimensional array of TableCellinfo the same size as the table grid
TableCellInfo[,] tci = new TableCellInfo[maxRow + 1, maxCol + 1];
for (int r = 0; r <= maxRow; r++)
for (int c = 0; c <= maxCol; c++)
tci[r, c] = new TableCellInfo();
// Read in each cell of the grid
idx = 0;
idxst = 0;
colPos = 0;
strow = 0;
int prevCol = 0;
int tstidx = 0;
string tstr = "";
bool incRow = false;
do
{
idx = txtbuff.IndexOfAny(test, idxst);
if (idx > -1)
{
switch (txtbuff[idx])
{
case '|': // end of column
colPos = idxst - strow;
// based on the position of the | char, find what column we are in.
// note that this will tell us if any columns to the left were merged
// the while loop will flag cell that need to be merged
curCol = dicCols[colPos];
while (curCol > prevCol + 1)
{
tci[curRow, prevCol].MergeColRight = true;
prevCol++;
}
prevCol = curCol;
// parse out the text to be placed in the table cell
tstr = txtbuff.Substring(idxst, idx - idxst);
if (tstr.Length == 0)
tstr += " ";
// test for a string of '-' characters
for (tstidx = 0; (tstidx < tstr.Length) && (tstr[tstidx] == '-'); tstidx++) ;
if (tstidx < tstr.Length) // not a full line (row) of '-' chars
{
// take a peek at the start of the next piece of table text to parse
// if it starts with a '-' char, then flag to merge the columns up to
// this point with the same columns in the next row
if (idx < txtbuff.Length - 1 && txtbuff[idx + 1] == '-')
{
for (int c = curCol; c >= 0; c--)
if (!tci[curRow, c].ColEnd)
tci[curRow, c].MergeRowBellow = true;
}
// if this column is in a merged grouping of rows,
// get the cell text in the first cell of the merged grouping of cells
// we will append the newly parsed text to this cell's text.
int rw = curRow;
while (rw - 1 >= 0 && tci[rw - 1, curCol].MergeRowBellow) rw--;
int cl = curCol;
while (cl - 1 >= 0 && tci[rw, cl-1].MergeColRight) cl--;
//string jstr = (string)this[rw, curCol];
string jstr = (string)this[rw, cl];
if (jstr == null)
jstr = tstr;
else
jstr += ((cl==curCol)? "\n" : "") + tstr; // multi line cell
//jstr += "\n" + tstr; // multi line cell
//this[rw, curCol] = jstr;
this[rw, cl] = jstr;
//// take a peek at the start of the next piece of table text to parse
//// if it starts with a '-' char, then flag to merge the columns up to
//// this point with the same columns in the next row
//if (idx < txtbuff.Length - 1 && txtbuff[idx + 1] == '-')
//{
// for (int c = curCol; c >= 0; c--)
// if (!tci[curRow, c].ColEnd)
// tci[curRow, c].MergeRowBellow = true;
//}
//int tcol = dicCols[idx];
//// if were are that the end of the 16-bit text line, but not in the last column,
//// merge the remaining columns to the right
//if (curCol < tcol)
//{
// for (int i = curCol; i <= tcol; i++)
// tci[curRow, i].MergeColRight = true;
//}
}
else // parsed text contains all dashes
{
// take a peek at the start of the next piece of table text to parse
// if it starts with a space, return, newline, or EndOfFile char,
// then flag to merge the columns up to
// this point with the same columns in the next row
if (idx < txtbuff.Length - 1 && " \r\n\x02".IndexOf(txtbuff[idx + 1]) > 0)
{
int nextCol = (curCol + 1 > this.Cols.Count) ? curCol : curCol + 1;
if (!tci[curRow, nextCol].ColEnd)
tci[curRow, nextCol].MergeRowBellow = true;
//for (int c = nextCol; c >= 0; c--)
// if (!tci[curRow, c].ColEnd)
// tci[curRow, c].MergeRowBellow = true;
}
tci[curRow, curCol].ColEnd = true;
incRow = true;
}
break;
case '\x02': // end of file
case '\n': // new line of 16-bit table text
colPos = idxst - strow;
curCol = dicCols[colPos];
// see what column we are in - new line might occure before last grid column
strow = idx + 1;
// parse out the cell text
tstr = txtbuff.Substring(idxst, idx - idxst);
if (tstr.EndsWith("\r")) // strip off carrage return
tstr = tstr.Substring(0, tstr.Length - 1);
//tstr = tstr.TrimEnd(" ".ToCharArray());
if (tstr.Length == 0)
tstr += " ";
// test for a string of '-' characters
for (tstidx = 0; (tstidx < tstr.Length) && (tstr[tstidx] == '-'); tstidx++) ;
if (tstidx < tstr.Length) // not a full line (row) of '-' chars
{
//curCol = dicCols[colPos];
while (curCol > prevCol + 1)
{
tci[curRow, prevCol].MergeColRight = true;
prevCol++;
}
// if this column is in a merged grouping of rows,
// get the cell text in the first cell of the merged grouping of cells
// we will append the newly parsed text to this cell's text.
int rw = curRow;
while (rw - 1 >= 0 && tci[rw - 1, curCol].MergeRowBellow) rw--;
int cl = curCol;
while (cl - 1 >= 0 && tci[rw, cl-1].MergeColRight) cl--;
//string jstr = (string)this[rw, curCol];
string jstr = (string)this[rw, cl];
if (jstr == null)
jstr = tstr;
else
jstr += ((cl == curCol) ? "\n" : "") + tstr; // multi line cell
//jstr += "\n" + tstr; // multi line cell
//this[rw, curCol] = jstr;
this[rw, cl] = jstr;
}
else if (tstr.Length > 0) // parsed text is all dash characters
{
incRow = true;
if (curRow > 0 && curCol > 0) // merge the column in the previous row with this one
tci[curRow - 1, curCol].MergeRowBellow = false;
}
// if were are that the end of the 16-bit text line, but not in the last column,
// merge the remaining columns to the right
if ((curCol < maxCol) && (tstidx < tstr.Length))
{
for (int i = curCol; i < maxCol; i++)
tci[curRow, i].MergeColRight = true;
}
if (incRow)
curRow++;
curCol = 0;
incRow = false;
break;
}
idxst = idx + 1;
if (idxst >= txtbuff.Length)
idx = -1;
}
else if (idxst < txtbuff.Length - 1) // handle any remaining text not yet parsed
{
// find the curent column and merge remaining columns to the right
colPos = idxst - strow;
curCol = dicCols.Count==0?0:dicCols[colPos];
while (curCol > prevCol + 1)
{
tci[curRow, prevCol].MergeColRight = true;
prevCol++;
}
// parse out the remaining text
tstr = txtbuff.Substring(idxst);
//tstr = tstr.TrimEnd(" ".ToCharArray());
if (tstr.Length == 0)
tstr += " ";
// test for a string of '-' characters
for (tstidx = 0; (tstidx < tstr.Length) && (tstr[tstidx] == '-'); tstidx++) ;
if (tstidx < tstr.Length)
{
// if this column is in a merged grouping of rows,
// get the cell text in the first cell of the merged grouping of cells
// we will append the newly parsed text to this cell's text.
int rw = curRow;
while (rw - 1 >= 0 && tci[rw - 1, curCol].MergeRowBellow) rw--;
int cl = curCol;
while (cl - 1 >= 0 && tci[rw, cl-1].MergeColRight) cl--;
//string jstr = (string)this[rw, curCol];
string jstr = (string)this[rw, cl];
if (jstr == null)
jstr = tstr;
else
jstr += ((cl == curCol) ? "\n" : "") + tstr; // multi line cell
//jstr += "\n" + tstr; // multi line cell
//this[rw, curCol] = jstr;
this[rw, cl] = jstr;
}
}
} while (idx != -1);
// we are done parsing the 16-bit text.
// now set the merge ranges in the table grid, based on the
// information saved in that two dimensional array of TableCellinfo
this.Rows.Count = curRow + 1;
this.AllowMerging = C1.Win.C1FlexGrid.AllowMergingEnum.Custom;
maxRow = curRow;
int rR = 0;
int rC = 0;
for (int r = 0; r <= maxRow; r++)
for (int c = 0; c <= maxCol; c++)
{
if (tci[r, c].MergeColRight)
{
rC = c;
while ((rC < maxCol) && (tci[r, rC].MergeColRight)) rC++;
if (rC > c)
{
this.MergedRanges.Add(this.GetCellRange(r, c, r, rC));
string cellstr = this[r, c].ToString();
for (int x = c + 1; x <= rC; x++)
this[r, x] = cellstr;
c = rC;
}
}
}
for (int c = 0; c <= maxCol; c++)
for (int r = 0; r <= maxRow; r++)
{
if (tci[r, c].MergeRowBellow)
{
rR = r;
while ((rR < maxRow) && (tci[rR, c].MergeRowBellow)) rR++;
if (rR > r)
{
this.MergedRanges.Add(this.GetCellRange(r, c, rR, c));
string cellstr = this[r, c].ToString();
for (int x = r + 1; x <= rR; x++)
this[x, c] = cellstr;
r = rR;
}
}
}
for (int c = 0; c <= maxCol; c++)
for (int r = 0; r <= maxRow; r++)
{
if (this[r, c] != null)
{
string cellstr = this[r, c].ToString();
this[r, c] = cellstr.TrimEnd("\r\n\t".ToCharArray());
//this[r, c] = cellstr.TrimEnd(" \r\n\t".ToCharArray());
CellRange cr = this.GetMergedRange(r, c);
if (cr.r1 != cr.r2)
TrimMergedRangeCellText(cr);
}
}
MyBorders = new VlnBorders(border, Rows.Count, Cols.Count);
}
private void TrimMergedRangeCellText(CellRange cr)
{
// count number of newlines
string cellstr = this[cr.r1, cr.c1].ToString();
string[] strary = cellstr.Split("\n".ToCharArray());
int nlines = strary.Length;
// count number of rows in merge range
int nrows = (cr.r2 - cr.r1) + 1;
int neededLines = (nlines - (nrows - 1));
bool bNeedToTrim = (nlines > neededLines);
string jstr = "";
int LinesToGo = neededLines;
if (bNeedToTrim)
{
int numBlanksEnd = 0;
// find the number of blank lines at the end of this table cell
for (int i = nlines-1; i >= 0; i--)
{
if (strary[i].Trim().Length == 0)
numBlanksEnd++;
else
break;
}
int preBlanksLines = 0;
//foreach (string tmpstr in strary)
// we ignore the ending blank lines
// this allows us to include any blank lines that are between text lines
for (int i = 0; i < nlines - numBlanksEnd; i++)
{
string tmpstr = strary[i];
int tlen = tmpstr.Trim().Length;
if (tlen > 0 || (LinesToGo < neededLines))
{
if (jstr.Length > 0) jstr += "\n";
jstr += tmpstr;
LinesToGo--;
}
else if (LinesToGo == (nlines - (nrows - 1)))
preBlanksLines++;
}
while (LinesToGo > 0)
{
// need to put this type of hard space (not \xA0) to hold the newline position
if (preBlanksLines > 0)
{
jstr = "\\~\n" + jstr;
LinesToGo--;
}
if (numBlanksEnd > 0)
{
jstr += "\n\\~";
LinesToGo--;
}
}
this[cr.r1, cr.c1] = jstr;
}
}
#endregion //Import / Export Grid
#region Bug Work Around
protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
{
// Note: this fixes a bug that happens when the grid has more rows than columns
// notified ComponentOne of the problem 6/25/09 via Email
try
{
base.OnMouseDown(e);
}
catch (Exception ex)
{
while (ex != null)
{
Console.WriteLine("{0} {1} {2}", ex.GetType().Name, ex.Message, ex.StackTrace);
ex = ex.InnerException;
}
}
}
#endregion //Bug Work Around
//public void CenterTheCellText()
//{
// // Cannot use this type of text allignment with RTF text cells
// CellRange cr = this.Selection;
// for (int rw = cr.r1; rw <= cr.r2; rw++)
// for (int col = cr.c1; col <= cr.c2; col++)
// {
// CellRange tmp = this.GetCellRange(rw, col, rw, col);
// string StyleName = string.Format("R{0}C{1}Style", rw, col);
// CellStyle cs = this.Styles.Add(StyleName, tmp.Style);
// cs.TextAlign = TextAlignEnum.CenterCenter;
// tmp.Style = cs;
// }
//}
#region Uneven Selections
/// <summary>
/// True if the top and bottom row of the selection is the same for every column
/// </summary>
public bool EvenSelection
{
get
{
if (Selection.c1 < 0 || Selection.c2 < 0 || Selection.r1 < 0 || Selection.r2 < 0) return true; // Even if there is no selection
if (Selection.IsSingleCell) return true; // One cell by definition is Even
int cMin = MinimumColumn(Selection.r1, Selection.c1); // Get the left column of the top row
int cMax = MaximumColumn(Selection.r1, Selection.c2); // Get the right column of the top row
for (int r = Selection.r1 + 1; r <= Selection.r2; r++)
{
// Uneven if the top row in this column doesn't match the first column
if (MinimumColumn(r, Selection.c1) != cMin)
return false;
// Uneven if the bottom row in this column doesn't match the first column
if (MaximumColumn(r, Selection.c2) != cMax)
return false;
}
int rMin = MinimumRow(Selection.r1, Selection.c1); // Get the top row of the left column
int rMax = MaximumRow(Selection.r2, Selection.c1); // Get the bottom row of the left column
for (int c = Selection.c1 + 1; c <= Selection.c2; c++)
{
// Uneven if the top row in this column doesn't match the first column
if (MinimumRow(Selection.r1, c) != rMin)
return false;
// Uneven if the bottom row in this column doesn't match the first column
if (MaximumRow(Selection.r2, c) != rMax)
return false;
}
return true;
}
}
public void MakeSelectionEven()
{
if (Selection.IsSingleCell) return; // One cell by definition is Even
MakeSelectionEven(Selection.r1, Selection.c1, Selection.r2, Selection.c2);
}
public void SelectRow()
{
MakeSelectionEven(Selection.r1, 0, Selection.r2, Cols.Count - 1);
}
public void SelectCol()
{
MakeSelectionEven(0, Selection.c1, Rows.Count - 1, Selection.c2);
}
public void MakeSelectionEven(int r1,int c1, int r2, int c2)
{
if (c1 < 0 || c2 < 0 || r1 < 0 || r2 < 0) return; // if there is no selection don't bother
CellRange cr = GetEvenSelection(r1, c1, r2, c2);
Select(cr);
}
public CellRange GetEvenSelection()
{
return GetEvenSelection(Selection.r1, Selection.c1, Selection.r2, Selection.c2);
}
public CellRange GetEvenSelection(int r1, int c1, int r2, int c2)
{
int cMinNew = MinimumColumn(r1, c1); // Get the left column of the top row
int cMaxNew = MaximumColumn(r1, c2); // Get the right column of the top row
int rMinNew = MinimumRow(r1, c1); // Get the top row of the left column
int rMaxNew = MaximumRow(r2, c1); // Get the bottom row of the left column
int cMin = cMinNew;
int cMax = cMaxNew;
int rMin = rMinNew;
int rMax = rMaxNew;
do
{
cMin = cMinNew;
cMax = cMaxNew;
rMin = rMinNew;
rMax = rMaxNew;
for (int r = rMin; r <= rMax; r++)
{
// Uneven if the top row in this column doesn't match the first column
int myMin = MinimumColumn(r, cMin);
if (myMin < cMinNew)
cMinNew = myMin;
// Uneven if the bottom row in this column doesn't match the first column
int myMax = MaximumColumn(r, cMax);
if (myMax > cMaxNew)
cMaxNew = myMax;
}
for (int c = cMinNew; c <= cMaxNew; c++)
{
// if the top row in this column is less than the minimum save it
int myMin = MinimumRow(rMin, c);
if (myMin < rMinNew)
rMinNew = myMin;
// Uneven if the bottom row in this column doesn't match the first column
int myMax = MaximumRow(rMax, c);
if (myMax > rMax)
rMaxNew = myMax;
}
}
while (cMinNew < cMin || cMaxNew > cMax || rMinNew < rMin || rMaxNew > rMax);
CellRange cr = GetCellRange(rMinNew, cMinNew, rMaxNew, cMaxNew);
return cr;
}
private int MinimumColumn(int r, int c)
{
return GetMergedRange(r, c).c1;
}
private int MaximumColumn(int r, int c)
{
return GetMergedRange(r, c).c2;
}
private int MinimumRow(int r, int c)
{
return GetMergedRange(r, c).r1;
}
private int MaximumRow(int r, int c)
{
return GetMergedRange(r, c).r2;
}
public Color StyleBackColor
{
get {return Styles.Normal.BackColor;}
set
{
Styles.Normal.BackColor = value;
Styles.Alternate.BackColor = value;
for (int c = 0; c < Cols.Count; c++)
for (int r = 0; r < Rows.Count; r++)
{
CellRange cr = GetMergedRange(r, c);
if (cr.Style != null && cr.Style.BackColor != value && cr.Style.Name != "Fixed")
{
cr.Style.BackColor = value;
//Console.WriteLine("{0}, {1}, {2}, {3}", r, c, cr.Style.Name, cr.Style.BackColor);
}
}
}
}
/// <summary>
/// Returns a list of cells or merged cells within the selection
/// </summary>
public List<CellRange> MySelection
{
get
{
List<CellRange> ranges = new List<CellRange>();
for (int c = Selection.c1; c <= Selection.c2; c++)
for (int r = Selection.r1; r <= Selection.r2; r++)
{
CellRange cr = GetMergedRange(r, c);
if (!ranges.Contains(cr))
ranges.Add(cr);
}
//}
return ranges;
}
}
/// <summary>
/// This is a test to see if MySelection works.
/// </summary>
public void BoldMySelection()
{
foreach (CellRange cr in MySelection)
{
using (StepRTB rtb = new StepRTB())
{
rtb.Rtf = GetCellRTFString(cr.r1, cr.c1);
rtb.SelectAll();
rtb.SelectionFont = new Font(rtb.SelectionFont, FontStyle.Bold);
this[cr.r1, cr.c1] = rtb.Rtf;
}
}
}
public void ShowMySelection()
{
int r1 = MySelection[0].r1;
int r2 = MySelection[0].r2;
int c1 = MySelection[0].c1;
int c2 = MySelection[0].c2;
foreach (CellRange cr in MySelection)
{
r1 = Math.Min(r1, cr.r1);
c1 = Math.Min(c1, cr.c1);
r2 = Math.Max(r2, cr.r2);
c2 = Math.Max(c2, cr.c2);
}
Select(r1,c1,r2,c2);
}
public void Debug_WritelineMySelection()
{
int r1 = MySelection[0].r1;
int r2 = MySelection[0].r2;
int c1 = MySelection[0].c1;
int c2 = MySelection[0].c2;
Console.WriteLine("Initial MySelection[0] {0}", MySelection[0]);
foreach (CellRange cr in MySelection)
{
r1 = Math.Min(r1, cr.r1);
c1 = Math.Min(c1, cr.c1);
r2 = Math.Max(r2, cr.r2);
c2 = Math.Max(c2, cr.c2);
Console.WriteLine("Foreach range ({0},{1}) - ({2},{3})", r1, c1, r2, c2);
}
}
#endregion
}
/// <summary>
/// This is used for storing the grid selection for copy/past Row/Column
/// </summary>
public enum GridCopyOption { Row, Column, Selection };
#region RTF Class for Cell rendering
/// <summary>
/// RTF Should only be used if the contents of the richtextbox are to be converted to an image.
/// </summary>
class RTF : StepRTB
{
// messages used by RichEd20.dll
internal const int
WM_USER = 0x0400,
EM_FORMATRANGE = WM_USER + 57;
// FORMATRANGE is used by RichEd20.dll to render RTF
internal struct FORMATRANGE
{
internal IntPtr hdc, hdcTarget;
internal Rectangle rc, rcPage;
internal int cpMin, cpMax;
}
// render the control directly into a given Graphics object
// (this does not honor clipping set in the target Graphics object; it that is
// a problem, use the RenderClipped method instead).
public void Render(Graphics g, Rectangle rc)
{
// convert rect from pixels to twips
rc.X = (int)(rc.X * 1440 / g.DpiX);
rc.Y = (int)(rc.Y * 1440 / g.DpiY);
rc.Width = rc.X + (int)((rc.Width) * 1440 / g.DpiX);
rc.Height = rc.Y + (int)((rc.Height) * 1440 / g.DpiY);
// get dc
IntPtr hdc = g.GetHdc();
// set up FORMATRANGE struct
FORMATRANGE fmt = new FORMATRANGE();
fmt.hdc = fmt.hdcTarget = hdc;
fmt.rc = fmt.rcPage = rc;
fmt.cpMin = 0;
fmt.cpMax = -1;
// render RTF
int render = 1;
SendMessageFormatRange(Handle, EM_FORMATRANGE, render, ref fmt);
// clean up
SendMessage(Handle, EM_FORMATRANGE, render, 0);
// done with dc
g.ReleaseHdc(hdc);
}
// render RTF into a Graphics object using a temporary bitmap to ensure
// clipping works correctly.
public void RenderClipped(Graphics g, Rectangle rc)
{
// create temp bitmap
Rectangle rcSrc = new Rectangle(0, 0, rc.Width, rc.Height);
using (Bitmap bmp = new Bitmap(rc.Width, rc.Height))
{
// render RTF into bitmap
using (Graphics gBmp = Graphics.FromImage(bmp))
{
Render(gBmp, rcSrc);
// transfer bitmap to original Graphics object
// (this honors clipping set in the target Graphics object)
g.DrawImage(bmp, rc, rcSrc, GraphicsUnit.Pixel);
}
}
}
// SendMessage
[DllImport("USER32.DLL", CharSet = CharSet.Auto)]
static private extern int SendMessage(
IntPtr hWnd,
uint wMsg,
int wParam,
int lParam);
[DllImport("USER32.DLL", CharSet = CharSet.Auto, EntryPoint = "SendMessage")]
static private extern int SendMessageFormatRange(
IntPtr hWnd,
uint wMsg,
int wParam,
ref FORMATRANGE lParam);
}
#endregion //RTF Class for Cell rendering
# region TableCellInfo for text parse
class TableCellInfo
{
private bool _MergeRowBellow;
public bool MergeRowBellow
{
get { return _MergeRowBellow; }
set { _MergeRowBellow = value; }
}
private bool _MergeColRight;
public bool MergeColRight
{
get { return _MergeColRight; }
set { _MergeColRight = value; }
}
private bool _ColEnd;
public bool ColEnd
{
get { return _ColEnd; }
set { _ColEnd = value; }
}
private string _Text;
public string Text
{
get { return _Text; }
set { _Text = value; }
}
}
#endregion //TableCellInfo for text parse
#region TableCellEditor
/// <summary>
/// TableCellEditor inherits from a StepRTB and is used as a custom cell editor
/// for the C1FlexGrid control.
/// </summary>
public class TableCellEditor : StepRTB //System.Windows.Forms.RichTextBox //System.Windows.Forms.TextBox // System.Windows.Forms.ComboBox
{
private VlnFlexGrid _owner;
private int _row, _col;
private char _pendingKey;
private bool _cancel;
public bool _initializingEdit;
// constructor: attach to owner grid
public TableCellEditor(VlnFlexGrid owner)
{
Visible = false;
AutoSize = false;
BackColor = Color.SkyBlue;
BorderStyle = BorderStyle.None;
ScrollBars = RichTextBoxScrollBars.None;
_initializingEdit = false;
_pendingKey = (char)0;
_cancel = false;
_owner = owner;
_owner.Controls.Add(this);
this.CursorMovement += new StepRTBCursorMovementEvent(TableCellEditor_CursorMovement);
this.CursorKeyPress += new StepRTBCursorKeysEvent(TableCellEditor_CursorKeyPress);
this.Leave += new EventHandler(_editor_Leave);
//this.HeightChanged += new StepRTBEvent(_HeightChanged);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
// start editing: move to cell and activate
public void StartEditing(int row, int col)
{
_initializingEdit = true;
ReadOnly = IsRoTable;
// save coordinates of cell being edited
_row = row;
_col = col;
//this.Clear(); //jsj
// assume we'll save the edits
_cancel = false;
// move editor over the current cell
Rectangle rc = _owner.GetCellRect(row, col, true);
rc.Width--;
rc.Height--;
Bounds = rc;
// initialize control content
Text = "";
FindAllLinks(); // jsj 1-5-2011
if (_pendingKey > ' ' && !ReadOnly)
Text = _pendingKey.ToString();
else if (_owner[row, col] != null)
{
string tmp = _owner[row, col].ToString();
if (tmp.StartsWith(@"{\rtf"))
Rtf = tmp.Replace(@"\~",@"\u160?");
else
Text = tmp;
}
Select(Text.Length, 0);
Size sz = new Size(rc.Width, rc.Height);
//this.Size = sz;
this.Width = rc.Width;
// make editor visible
Visible = true;
// and get the focus
//Select();
Focus();
_initializingEdit = false;
}
void TableCellEditor_CursorKeyPress(object sender, KeyEventArgs args)
{
//throw new Exception("The method or operation is not implemented.");
}
void TableCellEditor_CursorMovement(object sender, StepRTBCursorMovementEventArgs args)
{
int row = _owner.Selection.r1;
int col = _owner.Selection.c1;
CellRange cr = _owner.GetMergedRange(row, col);
//Console.WriteLine("keystroke {0} selection {1},{2}", args.Key, row, col);
//vlnStackTrace.ShowStack("keystroke {0} selection {1},{2}", args.Key, row, col);
_owner.Select();
// See if we are in a merged range of cells.
// if so, use the merged range instead of the selected range
// so that we can jump to the top/bottom/left/right of the range
// before attempting the move to the next grid cell.
//int idx = _owner.MergedRanges.IndexOf(row, col);
//if (idx > -1) cr = _owner.MergedRanges[idx];
switch (args.Key)
{
case VEPROMS.CSLA.Library.E_ArrowKeys.CtrlDown:
case VEPROMS.CSLA.Library.E_ArrowKeys.Down:
row = cr.r2;
if (row < _owner.Rows.Count - 1)
_owner.Select(_owner.GetMergedRange(row + 1, col));
else
_owner.OnCursorMovement(this, new VlnFlexGridCursorMovementEventArgs(args.Key));
break;
case VEPROMS.CSLA.Library.E_ArrowKeys.CtrlLeft:
case VEPROMS.CSLA.Library.E_ArrowKeys.Left:
col = cr.c1;
if (col > 0)
_owner.Select(_owner.GetMergedRange(row, col - 1));
else if(row > 0)
_owner.Select(_owner.GetMergedRange(row - 1, _owner.Cols.Count - 1));
else
_owner.OnCursorMovement(this, new VlnFlexGridCursorMovementEventArgs(args.Key));
break;
case VEPROMS.CSLA.Library.E_ArrowKeys.CtrlRight:
case VEPROMS.CSLA.Library.E_ArrowKeys.Right:
col = cr.c2;
if (col < _owner.Cols.Count - 1)
_owner.Select(_owner.GetMergedRange(row, col + 1));
else if (cr.r2 < _owner.Rows.Count - 1)
{
CellRange crDest = _owner.GetMergedRange(cr.r2 + 1, 0);
if (cr.r2 < crDest.r1) // It will move to the correct place
_owner.Select(crDest);
else if (crDest.r2 < _owner.Rows.Count)
_owner.Select(_owner.GetMergedRange(crDest.r2 + 1, 0));
else
_owner.OnCursorMovement(this, new VlnFlexGridCursorMovementEventArgs(args.Key));
}
else
_owner.OnCursorMovement(this, new VlnFlexGridCursorMovementEventArgs(args.Key));
break;
case VEPROMS.CSLA.Library.E_ArrowKeys.CtrlUp:
case VEPROMS.CSLA.Library.E_ArrowKeys.Up:
row = cr.r1;
if (row > 0)
_owner.Select(_owner.GetMergedRange(row - 1, col));
else
_owner.OnCursorMovement(this, new VlnFlexGridCursorMovementEventArgs(args.Key));
break;
default:
break;
}
//Console.WriteLine("selection {0}", _owner.Selection);
//_owner.Focus(); // focus was jumping out of the grid this keeps it in.
}
// after edit handler (custom editor)
void _editor_Leave(object sender, EventArgs e)
{
_owner.Invalidate();
_owner.AdjustGridControlSize();
}
//void _HeightChanged(object sender, EventArgs args)
//{
// _owner.Invalidate();
//}
// save key that started the editing mode
public void SetPendingKey(char chr)
{
_pendingKey = chr;
}
// expose internal variables
public bool Cancel { get { return _cancel; } }
public int Row { get { return _row; } }
public int Col { get { return _col; } }
// move editor after the grid has scrolled
public void UpdatePosition()
{
// get cell rect now
Rectangle rcCell = _owner.GetCellRect(_row, _col, false);
// intersect with scrollable part of the grid
Rectangle rcScroll = _owner.ClientRectangle;
rcScroll.X = _owner.Cols[_owner.Cols.Fixed].Left;
rcScroll.Y = _owner.Rows[_owner.Rows.Fixed].Top;
rcScroll.Width -= rcScroll.X;
rcScroll.Height -= rcScroll.Y;
rcCell = Rectangle.Intersect(rcCell, rcScroll);
// and move the control
if (rcCell.Width > 0) rcCell.Width--;
if (rcCell.Height > 0) rcCell.Height--;
Bounds = rcCell;
Size sz = new Size(_owner.GetCellRect(_row, _col).Width, _owner.GetCellRect(_row, _col).Height);
this.Size = sz;
}
// lost focus: hide the editor
override protected void OnLeave(System.EventArgs e)
{
// base processing
base.OnLeave(e);
// copy text to owner grid
if (!_cancel)
{
_owner[_row, _col] = Rtf; //Text;
}
// no more pending keys
_pendingKey = (char)0;
// done for now, hide editor
Visible = false;
}
// we will handle the Tab key ourselves
override protected bool IsInputKey(Keys keyData)
{
if (keyData == Keys.Tab) return true;
return base.IsInputKey(keyData);
}
//// some keys end the editing
//override protected void OnKeyDown(System.Windows.Forms.KeyEventArgs e)
//{
// switch (e.KeyCode)
// {
// case Keys.Escape: // cancel edits
// _cancel = true;
// _owner.Select();
// e.Handled = true;
// return;
// case Keys.Enter: // finish editing
// case Keys.Tab:
// case Keys.Up:
// case Keys.Down:
// case Keys.PageUp:
// case Keys.PageDown:
// _owner.Select();
// e.Handled = true;
// MoveCursor(e.KeyCode);
// return;
// default: // default processing
// base.OnKeyDown(e);
// return;
// }
//}
//// move cursor after done editing
//protected void MoveCursor(Keys key)
//{
// int row = _owner.Row;
// int col = _owner.Col;
// switch (key)
// {
// case Keys.Tab: col++; break;
// case Keys.Up: row--; break;
// //case Keys.Return: row++; break;
// case Keys.Down: row++; break;
// //case Keys.PageUp: row -= 10; break;
// //case Keys.PageDown: row += 10; break;
// }
// // validate new selection
// if (row < _owner.Rows.Fixed) row = _owner.Rows.Fixed;
// if (col < _owner.Cols.Fixed) col = _owner.Cols.Fixed;
// if (row > _owner.Rows.Count - 1) row = _owner.Rows.Count - 1;
// if (col > _owner.Cols.Count - 1) col = _owner.Cols.Count - 1;
// // apply new selection
// _owner.Select(row, col);
//}
//// suppress some keys to avoid annoying beep
//override protected void OnKeyPress(System.Windows.Forms.KeyPressEventArgs e)
//{
// switch (e.KeyChar)
// {
// case (char)27: // Keys.Escape:
// case (char)13: // Keys.Enter:
// case (char)9: // Keys.Tab:
// e.Handled = true;
// return;
// }
// base.OnKeyPress(e);
//}
}
#endregion // TableCellEditor
#region TableClipBoardFuncts Class
class TableClipBoardFuncts
{
DataFormats.Format dfmtTableCellRange = DataFormats.GetFormat("TableCellRange");
private SelectedTableCells mySeldTableCellsObject;
private DataObject myDataObject;
public TableClipBoardFuncts()
{
//mySeldTableCellsObject = new DataObject(dfmtTableCellRange.Name, seldTableCells);
}
public void Put(CellRange cr)
{
// Copies myObject into the clipboard.
// Clip get the value (text) of all the cells in the selected range
// This is saved as one RTF string.
Clipboard.SetDataObject(cr.Clip, true); // the "true" make the copy persistent
//Console.WriteLine("\nClip: '{0}' \n'{1}'", cr.Clip,cr.DataDisplay);
//mySeldTableCellsObject = new SelectedTableCells();
//mySeldTableCellsObject.CpbrdCellRange = cr;
// myDataObject = new DataObject(dfmtTableCellRange.Name, mySeldTableCellsObject);
// try
// {
// Clipboard.SetDataObject(myDataObject); //,true);
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.Message);
// }
}
public ArrayList Get()
{
// Retrieves the data from the clipboard.
IDataObject myRetrievedObject = Clipboard.GetDataObject();
string jj = (string)myRetrievedObject.GetData(DataFormats.Text);
return GetCellStrings(jj);
}
//public CellRange get_cr_Paste()
//{
// mySeldTableCellsObject = new SelectedTableCells();
// CellRange cr = new CellRange();
// SelectedTableCells sc;
// IDataObject myRetrievedObject = Clipboard.GetDataObject();
// try
// {
// //object obj = myRetrievedObject.GetData(dfmtTableCellRange.Name);
// object obj = myRetrievedObject.GetData("TableCellRange");
// //sc = (SelectedTableCells)myRetrievedObject.GetData(dfmtTableCellRange.Name);
// sc = (SelectedTableCells)obj;
// cr = sc.CpbrdCellRange;
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.Message);
// }
// return cr;
//}
private ArrayList GetCellStrings(string instr)
{
// The table cells placed on the clipboard is saved as one long RTF string.
// "\r\n\t" defines a cell border
// "\r\n\r" defines beginning of next line (row)
// This function will separate each cell text and place them in an array.
// This allow the clipboard information to be pasted independently from
// how it was selected.
// Bug fix: the CellRange.Clip (see cr.clip in the Put() function above) is replacing
// new lines with spaces. We need to put them back.
instr = instr.Replace(@"}} \", "}}\r\n\\");
string tstr = ""; // this will contain the parsed out cell text
ArrayList arylstCellStrings = new ArrayList();
int sidx = 0; // start index
int tidx = 0;
if (instr != null)
{
int idx = instr.IndexOf(@"{\rtf",sidx+1); // cell boarder
while (idx > 0)
{
tstr = instr.Substring(sidx, idx - sidx);
tstr = tstr.Substring(0, tstr.LastIndexOf('}') + 1);
//Console.WriteLine("\ntstr: '{0}'", tstr);
arylstCellStrings.Add(tstr);
sidx = idx;
idx = instr.IndexOf(@"{\rtf",sidx+1);
}
if (sidx < instr.Length)
{
tstr = instr.Substring(sidx);
arylstCellStrings.Add(tstr);
}
}
return arylstCellStrings;
}
//private ArrayList GetCellStrings(string instr)
//{
// // The table cells placed on the clipboard is saved as one long RTF string.
// // "\r\n\t" defines a cell border
// // "\r\n\r" defines beginning of next line (row)
// // This function will separate each cell text and place them in an array.
// // This allow the clipboard information to be pasted independently from
// // how it was selected.
// string tstr = ""; // this will contain the parsed out cell text
// ArrayList arylstCellStrings = new ArrayList();
// int sidx = 0; // start index
// int tidx = 0;
// if (instr != null)
// {
// int idx = instr.IndexOf("\r\n\t"); // cell boarder
// if (idx < 0) idx = instr.IndexOf("\r\n\r"); // new line (needed for multiple lines in one cell)
// while (idx > 0)
// {
// tstr = instr.Substring(sidx, idx - sidx);
// tidx = tstr.IndexOf("\r\n\r");
// if (tidx > 0)
// {
// idx = instr.IndexOf("\r\n\r", sidx);
// tstr = instr.Substring(sidx, idx - sidx);
// }
// arylstCellStrings.Add(tstr.Substring(tstr.IndexOf("{\\rtf")));
// sidx = idx + 3;
// if (sidx < instr.Length)
// {
// idx = instr.IndexOf("\r\n\t", sidx);
// if (idx < 0) idx = instr.IndexOf("\r\n\r", sidx);
// }
// }
// if (sidx < instr.Length)
// {
// tstr = instr.Substring(sidx);
// arylstCellStrings.Add(tstr.Substring(tstr.IndexOf("{\\rtf")));
// }
// }
// return arylstCellStrings;
//}
}
[Serializable]
public class SelectedTableCells : Object
{
private CellRange _cpbrdCellRange;
public CellRange CpbrdCellRange
{
get { return _cpbrdCellRange; }
set { _cpbrdCellRange = value; }
}
public SelectedTableCells()
{
}
}
#endregion // TableClipBoardFuncts Class
public class VlnFlexGridCursorMovementEventArgs
{
private E_ArrowKeys _Key;
public E_ArrowKeys Key
{
get { return _Key; }
set { _Key = value; }
}
public VlnFlexGridCursorMovementEventArgs(E_ArrowKeys key)
{
_Key = key;
}
}
public class VlnFlexGridPasteEventArgs
{
private string _Text;
public string Text
{
get { return _Text; }
set { _Text = value; }
}
public VlnFlexGridPasteEventArgs(string text)
{
_Text = text;
}
}
public class GridCopyInfo
{
private GridCopyOption _MyCopyOption = GridCopyOption.Selection;
public GridCopyOption MyCopyOption
{
get { return _MyCopyOption; }
set
{
//Console.WriteLine("MyCopyOption = {0}", _MyCopyOption);
//if (_MyCopyOption != value)
// Console.WriteLine("Changed Option to {0}", value);
_MyCopyOption = value;
}
}
private VlnFlexGrid _MyCopiedFlexGrid = null;
public VlnFlexGrid MyCopiedFlexGrid
{
get { return _MyCopiedFlexGrid; }
set { _MyCopiedFlexGrid = value; }
}
private CellRange _MyCopiedCellRange;
public CellRange MyCopiedCellRange
{
get { return _MyCopiedCellRange; }
set { _MyCopiedCellRange = value; }
}
}
}
Reference in New Issue View Git Blame Copy Permalink