public void SetOn(bool symmetry)
{
if (gameObject.GetComponent <WireframeComponent>() == null)
{
gameObject.AddComponent <WireframeComponent>();
}
if (_thrustArrows == null)
{
ModuleEngines engineMod;
if (FindEngineModule(gameObject, out engineMod))
{
_thrustArrows = new List <ThrustArrowComponent>();
for (var i = 0; i < engineMod.thrustTransforms.Count; i++)
{
var go = new GameObject("Thrust Transform Arrow Renderer");
go.transform.parent = engineMod.thrustTransforms[i].transform;
go.transform.localPosition = Vector3.zero;
_thrustArrows.Add(go.AddComponent <ThrustArrowComponent>());
}
}
}
if (symmetry)
{
return;
}
_state = RendererState.Active;
Events["ColliderHelperEvent"].guiName = "Show Collider: On";
}
/// <summary>
/// Create a slice header table that will contain the slice key titles and values
/// </summary>
/// <param name="state">
/// The current state
/// </param>
/// <returns>
/// The slice header table
/// </returns>
protected Table CreateSliceHeaderTable(RendererState state)
{
var table = new Table();
table.AddClass(HtmlClasses.SliceKeys);
table.AddAttribute(HtmlConstants.CellPadding, ZeroValue);
table.AddAttribute(HtmlConstants.CellSpacing, ZeroValue);
foreach (string key in state.Model.SliceKeys)
{
var row = new TableRow();
table.AddElement(row);
var value = state.InputRow[key] as string;
value = value ?? " ";
var title = new TableCell(state.Model.AllValidKeys[key]);
title.AddClass(HtmlClasses.SliceKeyTitle);
row.AddElement(title);
string text = this.GetLocalizedName(key, value);
var val = new TableCell();
// Implemented like in java to show description only
val.SetupDisplayText(value, text, key, DisplayMode.Description, false);
val.AddClass(HtmlClasses.SliceKeyValue);
row.AddElement(val);
}
return(table);
}
/// <summary>
/// Initialize the render pipleline.
/// </summary>
/// <param name="leftcamera">Left Eye.</param>
/// <param name="rightcamera">Right Eye.</param>
/// <param name="poseprovider">provide the pose of camera every frame.</param>
public void Initialize(Camera leftcamera, Camera rightcamera, PoseProvideDelegage poseprovider)
{
if (m_CurrentState != RendererState.UnInitialized)
{
return;
}
NRSessionManager.SetAppSettings(true);
leftCamera = leftcamera;
rightCamera = rightcamera;
OnUpdatePose = poseprovider;
#if !UNITY_EDITOR
leftCamera.depthTextureMode = DepthTextureMode.Depth;
rightCamera.depthTextureMode = DepthTextureMode.Depth;
leftCamera.rect = new Rect(0, 0, 1, 1);
rightCamera.rect = new Rect(0, 0, 1, 1);
leftCamera.enabled = false;
rightCamera.enabled = false;
CreateRenderTextures();
m_CurrentState = RendererState.Initialized;
Invoke("StartUp", 0.3f);
#endif
}
public void Close(bool force = false)
{
logger.Debug("D3DImageRenderer::Close(...) " + force);
Stop();
if (!force)
{
if (renderTask != null)
{
if (renderTask.Status == TaskStatus.Running)
{
bool waitResult = false;
do
{
waitResult = renderTask.Wait(1000);
if (!waitResult)
{
logger.Warn("D3DImageProvider::Close() " + waitResult);
state = RendererState.Stopping;
}
} while (!waitResult);
}
}
}
CleanUp();
}
public void SetOff(bool recursive)
{
if (recursive)
{
for (var i = 0; i < part.symmetryCounterparts.Count; i++)
{
var helperComponent = part.symmetryCounterparts[i].GetComponent <ModuleColliderHelper>();
helperComponent?.SetOff(false);
}
}
var renderComponent = gameObject.GetComponent <WireframeComponent>();
if (renderComponent != null)
{
Destroy(renderComponent);
}
if (_thrustArrows != null)
{
for (var i = 0; i < _thrustArrows.Count; i++)
{
DestroyImmediate(_thrustArrows[i].gameObject);
}
_thrustArrows = null;
}
_state = RendererState.Off;
Events["ColliderHelperEvent"].guiName = "Show Collider: Off";
}
/// <summary>
/// Set vertical row span in <see cref="RendererState.VerticalOrderedRows"/>.
/// </summary>
/// <param name="s">
/// The <see cref="RendererState"/> containing the vertical ordered rows
/// </param>
private static void SetupVerticalRowSpan(RendererState s)
{
int keyCount = s.Model.VerticalKeys.Count - 1;
if (keyCount < 1)
{
// we don't care about colspan if there is only one or less vertical keys
return;
}
// The TD per TR that will be deleted
var toDeleteTableCells = new Dictionary <TableRow, List <TableCell> >();
// the previous row values
var previousValues = new string[keyCount];
var firstTableCell = new TableCell[keyCount];
for (int v = 0; v < s.VerticalOrderedRows.Count; v++)
{
// for each TR row
var row = s.VerticalOrderedRows[v];
for (int i = 0; i < keyCount; i++)
{
// for each vertical key column
var cell = row.Children[i];
if (!string.Equals(cell.Text, previousValues[i]))
{
// if the current key value doesn't equal the previous row value
previousValues[i] = cell.Text; // set the previous value to the current
for (int x = i + 1; x < keyCount; x++)
{
// reset any previous values from keys that follow the current
previousValues[x] = null;
}
firstTableCell[i] = cell;
}
else
{
firstTableCell[i].RowSpan++;
List <TableCell> deleteList;
if (!toDeleteTableCells.TryGetValue(row, out deleteList))
{
deleteList = new List <TableCell>();
toDeleteTableCells.Add(row, deleteList);
}
deleteList.Add(cell);
}
}
}
foreach (KeyValuePair <TableRow, List <TableCell> > entry in toDeleteTableCells)
{
foreach (TableCell cell in entry.Value)
{
entry.Key.Children.Remove(cell);
}
}
}
protected void ChangeState(RendererState newState)
{
lock (_stateLock)
{
_state = newState;
}
}
private void CleanUp()
{
logger.Verb("D3DImageRenderer::CleanUp()");
//System.Windows.Media.CompositionTarget.Rendering -= CompositionTarget_Rendering;
if (surface != null)
{
surface.Dispose();
surface = null;
}
if (direct3D != null)
{
direct3D.Dispose();
direct3D = null;
}
if (device != null)
{
device.Dispose();
device = null;
}
if (waitEvent != null)
{
waitEvent.Dispose();
waitEvent = null;
}
state = RendererState.Closed;
}
/// <summary>
/// Initialize the horizontal and vertical key titles
/// </summary>
/// <param name="state">
/// The current <see cref="RendererState"/>
/// </param>
protected void InitTitles(RendererState state)
{
state.VerticalKeyTitles = this.CreateVerticalTitles(state.Model);
// There will be exactly one row for each horizontal dimension (for both title & possible values)...
this.CreateHorizontalTitles(state.Model, state.HorizontalKeyRows, state.HorizontalOrderedRows);
}
/// <summary>
/// Write all data splitted in slices to the specified writer
/// </summary>
/// <param name="model">
/// The model to write
/// </param>
/// <param name="writer">
/// The writer to use
/// </param>
protected override void WriteTableModels(IDataSetModel model, TextWriter writer)
{
IDataReader allData = model.GetReader(false);
string oldKeySetSlice = null;
var s = new RendererState(model);
while (allData.Read())
{
s.InputRow = allData;
string currentKeySet = MakeKey(model.SliceKeys, allData);
if (!currentKeySet.Equals(oldKeySetSlice))
{
oldKeySetSlice = currentKeySet;
this.CommitTable(s, writer);
Table sliceHeaderTable = this.CreateSliceHeaderTable(s);
sliceHeaderTable.WriteCsv(writer, this._separator);
s.Table = CreateSliceTable();
this.InitTitles(s);
}
this.ParseDataRow(s);
}
allData.Close();
s.InputRow = null;
this.CommitTable(s, writer);
}
/// <summary>
/// Write all data splitted in slices to the specified writer
/// </summary>
/// <param name="model">
/// The dataset model
/// </param>
/// <param name="doc">
/// The PDF document
/// </param>
private void WriteTableModels(IDataSetModel model, IDocListener doc)
{
IDataReader reader = model.GetReader(false);
// DIV containerTable = createContainerTable();
string oldKeySet = null;
var s = new RendererState(model);
while (reader.Read())
{
s.InputRow = reader;
string currentKeySet = MakeKey(model.SliceKeys, reader);
if (!currentKeySet.Equals(oldKeySet))
{
oldKeySet = currentKeySet;
CommitTable(s, doc);
// containerTable = createContainerTable();
this.CreateSliceHeader(doc, s);
// addSliceHeading(containerTable, sTable);
s.Table = CreateSliceTable();
// addSliceTable(containerTable, s.table);
this.InitTitles(s);
}
this.ParseDataRow(s);
}
reader.Close();
s.InputRow = null;
CommitTable(s, doc);
}
/// <summary>
/// Render to the specified writer the current slide as a html table
/// </summary>
/// <param name="model">
/// The model to render
/// </param>
/// <param name="os">
/// The output to write to
/// </param>
public virtual void Render(IDataSetModel model, TextWriter os)
{
var s = new RendererState(model);
Table table = this.CreateTableModel(s);
// Table table = this.createTableModel(model);
table.Write(os);
}
/// <summary>
/// Commit the current table and reset state
/// </summary>
/// <param name="s">
/// The state
/// </param>
/// <param name="writer">
/// The writer to commit the current table
/// </param>
private void CommitTable(RendererState s, TextWriter writer)
{
if (s.Table != null)
{
PopulateTable(s);
s.Table.WriteLineCsv(writer, this._separator);
s.Reset();
}
}
/// <summary>
/// Pause render.
/// </summary>
public void Pause()
{
if (m_CurrentState != RendererState.Running)
{
return;
}
m_CurrentState = RendererState.Paused;
GL.IssuePluginEvent(RenderThreadHandlePtr, PAUSENATIVERENDEREVENT);
}
private void DelayResume()
{
if (m_CurrentState != RendererState.Paused)
{
return;
}
m_CurrentState = RendererState.Running;
GL.IssuePluginEvent(RenderThreadHandlePtr, RESUMENATIVERENDEREVENT);
}
public void Destroy()
{
if (m_CurrentState == RendererState.Destroyed)
{
return;
}
m_CurrentState = RendererState.Destroyed;
GL.IssuePluginEvent(RenderThreadHandlePtr, STOPNATIVERENDEREVENT);
}
public override unsafe void PaintLine(IntPtr hdc, RendererState rs)
{
if (this._handleFont == null)
{
using (var f = new Font(rs.TextView.Font.FontFamily, rs.TextView.Font.Size - 2))
{
this._handleFont = new SafeHandleGDI(f.ToHfont());
}
this._handlePen = new SafeHandleGDI(SafeNativeMethods.CreatePen(NativeConstants.PS_SOLID, -1, ColorTranslator.ToWin32(Color.Silver)));
this._handleBkBrush = new SafeHandleGDI(SafeNativeMethods.CreateSolidBrush(ColorTranslator.ToWin32(Color.White)));
this._handleBkActiveBrush = new SafeHandleGDI(SafeNativeMethods.CreateSolidBrush(ColorTranslator.ToWin32(Color.FromArgb(240, 240, 250))));
}
var str = (rs.LineIndexVirtual + 1).ToString();
var textLength = rs.TextView.GetVisualLineCount().ToString().Length;
if (textLength != this._previousLength)
{
// We check if the number of lines have changed to contain an extra character.
// In that case we'll need to perform a layout calculation for the whole text control.
// So, call on PerformLayout(). This *might* screw up the current painting, but it is very inlikely.
this._previousLength = textLength;
rs.TextView.PerformLayout();
}
fixed(char *c = str)
{
var isCurrentLine = rs.LineIndexVirtual == rs.LineIndexVirtualFocused;
var previousFont = SafeNativeMethods.SelectObject(hdc, this._handleFont.DangerousGetHandle());
var previousPen = SafeNativeMethods.SelectObject(hdc, this._handlePen.DangerousGetHandle());
var color = isCurrentLine ? Color.DimGray : Color.LightSteelBlue;
var previousForeColor = SafeNativeMethods.SetTextColor(hdc, ColorTranslator.ToWin32(color));
var previousBkMode = SafeNativeMethods.SetBkMode(hdc, NativeConstants.TRANSPARENT);
var r = new RECT
{
top = rs.Y - rs.ViewportY,
right = rs.X + this.Width,
bottom = rs.Y + rs.LineHeight,
left = rs.X
};
SafeNativeMethods.FillRect(hdc, ref r, this._handleBkActiveBrush.DangerousGetHandle());
SafeNativeMethods.MoveToEx(hdc, rs.X + this.Width, rs.Y - rs.ViewportY, IntPtr.Zero);
SafeNativeMethods.LineTo(hdc, rs.X + this.Width, rs.Y + rs.LineHeight - rs.ViewportY);
SafeNativeMethods.TextOut(hdc, 2 + rs.X, rs.Y - rs.ViewportY, c, str.Length);
SafeNativeMethods.SelectObject(hdc, previousPen);
SafeNativeMethods.SetTextColor(hdc, previousForeColor);
SafeNativeMethods.SetBkMode(hdc, previousBkMode);
SafeNativeMethods.SelectObject(hdc, previousFont);
}
}
protected void ChangeState(RendererState expectedState, RendererState newState)
{
lock (_stateLock)
{
if (_state == expectedState)
{
_state = newState;
}
}
}
public void Stop()
{
logger.Debug("D3DImageRenderer::Stop()");
state = RendererState.Stopping;
VideoSource = null;
waitEvent?.Set();
//timer.Stop();
}
/// <summary>
/// Create the slice header
/// </summary>
/// <param name="doc">
/// The <see cref="Document"/>
/// </param>
/// <param name="state">
/// The current <see cref="HtmlRenderer.RendererState"/>
/// </param>
private void CreateSliceHeader(IElementListener doc, RendererState state)
{
Table headerTable = this.CreateSliceHeaderTable(state);
PdfPTable table = CreatePdf(headerTable);
if (table != null)
{
doc.Add(table);
table.DeleteBodyRows();
}
}
public Renderer(GraphicsDevice graphicsDevice, Effect defaultShader)
{
this.defaultShader = defaultShader;
Font = null;
Camera = null;
ResetTint();
spriteBatch = new SpriteBatch(graphicsDevice);
skeletonRenderer = new SkeletonRenderer(graphicsDevice);
skeletonRenderer.BlendState = BlendState.NonPremultiplied;
state = RendererState.NoneBegan;
CurrentShader = null;
}
private void beginSkeletonRenderer()
{
if (state != RendererState.SkeletonRendererBegan)
{
if (state == RendererState.SpriteBatchBegan)
{
spriteBatch.End();
}
skeletonRenderer.Begin(CurrentShader);
state = RendererState.SkeletonRendererBegan;
}
}
private void beginSpriteBatch()
{
if (state != RendererState.SpriteBatchBegan)
{
if (state == RendererState.SkeletonRendererBegan)
{
skeletonRenderer.End();
}
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, null, null, null, CurrentShader);
state = RendererState.SpriteBatchBegan;
}
}
public void End()
{
if (state == RendererState.SpriteBatchBegan)
{
spriteBatch.End();
}
else if (state == RendererState.SkeletonRendererBegan)
{
skeletonRenderer.End();
}
state = RendererState.NoneBegan;
}
public Renderer(GraphicsDevice graphicsDevice, Effect defaultShader)
{
this.defaultShader = defaultShader;
Font = null;
Camera = null;
ResetTint();
spriteBatch = new SpriteBatch(graphicsDevice);
skeletonRenderer = new SkeletonRenderer(graphicsDevice);
skeletonRenderer.BlendState = BlendState.NonPremultiplied;
state = RendererState.NoneBegan;
CurrentShader = null;
}
/// <summary>
/// Populate the Slice table
/// </summary>
/// <param name="state">
/// The State object that contains the data that will be used to populate the slice table
/// </param>
protected static void PopulateTable(RendererState state)
{
state.Table.Add(state.HorizontalOrderedRows);
if (state.VerticalKeyTitles.Children.Count > 0 && state.VerticalOrderedRows.Count > 0)
{
int dataLength = state.VerticalOrderedRows[0].Children.Count - state.VerticalKeyTitles.Children.Count;
var empty = new TableCell();
empty.SetColSpan(dataLength);
state.VerticalKeyTitles.AddElement(empty);
state.Table.AddElement(state.VerticalKeyTitles);
}
state.VerticalOrderedRows.Sort(new VerticalKeyComparer(state.Model.VerticalKeys.Count));
SetupVerticalRowSpan(state);
state.Table.Add(state.VerticalOrderedRows);
}
private void StartUp()
{
leftCamera.enabled = true;
rightCamera.enabled = true;
#if !UNITY_EDITOR
m_NativeRenderring = new NativeRenderring();
m_NativeRenderring.Create();
#if !UNITY_STANDALONE_WIN
m_NativeRenderring.InitColorSpace();
#endif
StartCoroutine(RenderCoroutine());
#endif
m_CurrentState = RendererState.Running;
GL.IssuePluginEvent(RenderThreadHandlePtr, STARTNATIVERENDEREVENT);
}
/// <summary>
/// Commit the current table and reset state
/// </summary>
/// <param name="state">
/// The state
/// </param>
/// <param name="doc">
/// The pdf document to commit the current table
/// </param>
private static void CommitTable(RendererState state, IDocListener doc)
{
if (state.Table != null)
{
PopulateTable(state);
// containerTable.Write(writer);
PdfPTable table = CreatePdf(state.Table);
if (table != null)
{
doc.Add(table);
table.DeleteBodyRows();
}
doc.NewPage();
state.Reset();
}
}
public void SetSymmetry(bool recursive)
{
if (recursive)
{
for (var i = 0; i < part.symmetryCounterparts.Count; i++)
{
var component = part.symmetryCounterparts[i].GetComponent <ModuleColliderHelper>();
component?.SetSymmetry(false);
}
}
SetOn(true);
_state = RendererState.Symmetry;
Events["ColliderHelperEvent"].guiName = "Show Collider: Symmetry";
}
/// <summary>
/// Write all data splitted in slices to the specified writer
/// </summary>
/// <param name="model">
/// The model to write
/// </param>
/// <param name="writer">
/// The writer to use
/// </param>
protected virtual void WriteTableModels(IDataSetModel model, TextWriter writer)
{
IDataReader allData = model.GetReader(false);
Table containerTable = CreateContainerTable();
string oldKeySet = null;
var s = new RendererState(model);
while (allData.Read())
{
s.InputRow = allData;
string currentKeySet = MakeKey(model.SliceKeys, allData);
if (!currentKeySet.Equals(oldKeySet))
{
oldKeySet = currentKeySet;
if (s.Table != null)
{
PopulateTable(s);
containerTable.Write(writer);
s.Reset();
}
containerTable = CreateContainerTable();
Table sliceHeaderTable = this.CreateSliceHeaderTable(s);
AddSliceHeading(containerTable, sliceHeaderTable);
s.Table = CreateSliceTable();
AddSliceTable(containerTable, s.Table);
this.InitTitles(s);
}
this.ParseDataRow(s);
}
allData.Close();
s.InputRow = null;
if (s.Table != null)
{
PopulateTable(s);
containerTable.Write(writer);
s.Reset();
}
}
public void Start()
{
logger.Debug("D3DImageRenderer::Start()");
if (!(state == RendererState.Stopped || state == RendererState.Initialized))
{
throw new InvalidOperationException("Invalid renderer state " + State);
}
// OnPropertyChanged(nameof(ScreenView));
renderTask = Task.Run(() =>
{
logger.Debug("Render thread started...");
state = RendererState.Rendering;
RenderStarted?.Invoke();
//OnPropertyChanged(nameof(ScreenView));
try
{
while (State == RendererState.Rendering)
{
Draw();
waitEvent?.WaitOne(1000);
}
}
catch (Exception ex)
{
logger.Error(ex);
errorCode = MediaToolkit.SharedTypes.ErrorCode.Fail;
}
finally
{
state = RendererState.Stopped;
RenderStopped?.Invoke(null);
logger.Debug("Render thread stopped...)");
}
});
// timer.Start();
}
/// <summary>
/// Commit the current table and reset state
/// </summary>
/// <param name="s">
/// The state
/// </param>
/// <param name="writer">
/// The writer to commit the current table
/// </param>
private void CommitTable(RendererState s, TextWriter writer)
{
if (s.Table != null)
{
PopulateTable(s);
s.Table.WriteLineCsv(writer, this._separator);
s.Reset();
}
}
/// <summary>
/// Parse a data row and populate the <see cref="RendererState.CurrentTableRow"/> with the X, Y axis key values and the data
/// </summary>
/// <param name="state">
/// The current state
/// </param>
protected virtual void ParseDataRow(RendererState state)
{
// check if something has changed
state.HorizontalCurrentKeySet = MakeKey(state.Model.HorizontalKeys, state.InputRow);
if (!string.Equals(state.HorizontalCurrentKeySet, state.HorizontalOldKeySet))
{
state.CurrentHorizontalKeySetColumn++;
state.HorizontalOldKeySet = state.HorizontalCurrentKeySet;
foreach (TableRow row in state.VerticalKeySetIndex.Values)
{
row.AddElement(new TableCell(" "));
}
foreach (string dim in state.Model.HorizontalKeys)
{
TableRow horizontalKeyRow = state.HorizontalKeyRows[dim];
var currentValue = state.InputRow[dim] as string;
this.AddHorrizontalKeyValues(
state.VerticalPreviousValuesMap, dim, horizontalKeyRow, currentValue, state.Model);
}
}
state.VerticalCurrentKeySet = MakeKey(state.Model.VerticalKeys, state.InputRow);
TableRow currentRow;
if (!state.VerticalKeySetIndex.TryGetValue(state.VerticalCurrentKeySet, out currentRow))
{
state.CurrentTableRow = new TableRow();
if (state.Model.VerticalKeys.Count == 0 && state.Model.HorizontalKeys.Count > 0)
{
state.CurrentTableRow.AddElement(new TableCell(" "));
}
state.VerticalKeySetIndex.Add(state.VerticalCurrentKeySet, state.CurrentTableRow);
state.VerticalOrderedRows.Add(state.CurrentTableRow);
foreach (string dim in state.Model.VerticalKeys)
{
var currentValue = state.InputRow[dim] as string;
this.AddVerticalKeyValues2(
state.HorizontalPreviousValuesMap, dim, state.CurrentTableRow, currentValue, state.Model);
}
int currentVerticalKeyValueCount = state.CurrentTableRow.Children.Count;
state.VerticalKeyValueCount.Add(state.VerticalCurrentKeySet, currentVerticalKeyValueCount);
state.CurrentVerticalKeyValueCount = currentVerticalKeyValueCount;
for (int i = 0; i < state.CurrentHorizontalKeySetColumn; i++)
{
state.CurrentTableRow.AddElement(new TableCell(" "));
}
}
else
{
state.CurrentTableRow = currentRow;
state.CurrentVerticalKeyValueCount = state.VerticalKeyValueCount[state.VerticalCurrentKeySet];
}
var val = state.InputRow[state.Model.KeyFamily.PrimaryMeasure.Id] as string;
if (string.IsNullOrEmpty(val))
{
val = " ";
}
int column = state.CurrentHorizontalKeySetColumn + state.CurrentVerticalKeyValueCount;
var measure = new TableCell(ReplaceDecimalSeparator(val));
measure.AddClass(HtmlClasses.Measure);
state.CurrentTableRow.AddAt(measure, column);
}
/// <summary>
/// Create a single slice table for the specified Layout.
/// </summary>
/// <param name="state">
/// The current state
/// </param>
/// <returns>
/// The slice <see cref="Table"/>
/// </returns>
private Table CreateTableModel(RendererState state)
{
state.Table = CreateSliceTable();
if (AllKeysAreSlice(state.Model))
{
GetSingleValue(state.Model, state.Table);
return state.Table;
}
this.InitTitles(state);
IDataReader reader = state.Model.GetReader(true);
while (reader.Read())
{
state.InputRow = reader;
this.ParseDataRow(state);
}
reader.Close();
PopulateTable(state);
return state.Table;
}
/// <summary>
/// Create a single slice table for the specified Layout.
/// </summary>
/// <param name="state">
/// The current state
/// </param>
/// <returns>
/// The slice <see cref="Table"/>
/// </returns>
private Table CreateTableModel(RendererState state)
{
state.Table = CreateSliceTable();
if (AllKeysAreSlice(state.Model))
{
GetSingleValue(state.Model, state.Table);
return state.Table;
}
this.InitTitles(state);
IDataReader reader = state.Model.GetReader(true);
var v = new Dictionary<string, decimal>();
//reader = state.Model.GetReader(true);
while (reader.Read())
{
state.InputRow = reader;
#region Calcolo variazioni
decimal obs = 0;
object vt = null;
object vc = null;
var obs_val = reader.GetValue(reader.GetOrdinal("OBS_VALUE"));
var time_p = reader.GetValue(reader.GetOrdinal("TIME_PERIOD"));
bool is_obs_value = false;
try
{
obs = Convert.ToDecimal(obs_val.ToString(), cFrom);
is_obs_value = true;
}
catch {
is_obs_value = false;
}
if (is_obs_value)
{
int anno = 0;
int period = 0;
bool _errTimePeriod = false;
bool _annual = !((string)time_p).Contains("-");
bool _quater = false;
bool _seme = false;
#region ESTRAGGO ANNO E PERIOD
if (_annual)
{
_errTimePeriod = !(int.TryParse(((string)time_p), out anno));
}
else
{
_errTimePeriod = !(int.TryParse(((string)time_p).Split('-')[0], out anno));
string _p = ((string)time_p).Split('-')[1];
if (_quater = _p.StartsWith("Q")) _p = _p.Substring(1);
if (_seme = _p.StartsWith("S")) _p = _p.Substring(1);
_errTimePeriod = !(int.TryParse(_p, out period));
}
#endregion
if (!_errTimePeriod)
{
string serieKeyStr = string.Empty;
foreach (var dim in state.Model.KeyFamily.DimensionList.Dimensions)
{
serieKeyStr += (string)((serieKeyStr != string.Empty) ? "+" : string.Empty);
serieKeyStr += (dim.Id != state.Model.KeyFamily.TimeDimension.Id) ? reader[dim.Id] : string.Empty;
}
string vi_k = string.Empty;
string vf_k = string.Empty;
// Calcolo variazione congiunturale
vf_k = serieKeyStr + anno + "_" + (period);
if (!_annual)
if (period == 1)
if (_seme)
vi_k = serieKeyStr + (anno - 1) + "_2";
else if (_quater)
vi_k = serieKeyStr + (anno - 1) + "_4";
else
vi_k = serieKeyStr + (anno - 1) + "_12";
else
vi_k = serieKeyStr + anno + "_" + (period - 1);
else vi_k = serieKeyStr + (anno - 1) + "_" + (period);
var vi = (v.ContainsKey(vi_k.ToString())) ? (object)v[vi_k] : null;
try
{
decimal _vi = Convert.ToDecimal(vi, cFrom);
if (_vi == 0) vc = null;
else vc = Math.Round((((obs - _vi) / _vi) * 100), 1);
}
catch
{
vc = null;
}
// Calcolo variazione tendenziale
vi_k = serieKeyStr + (anno - 1) + "_" + (period);
vf_k = serieKeyStr + anno + "_" + (period);
vi = (v.ContainsKey(vi_k.ToString())) ? (object)v[vi_k] : null;
try
{
decimal _vi = Convert.ToDecimal(vi, cFrom);
if (_vi == 0) vt = null;
else vt = Math.Round((((obs - _vi) / _vi) * 100), 1);
}
catch { vt = null; }
v.Add(vf_k, obs);
}
}
#endregion
this.ParseDataRow(state, vc, vt);
}
reader.Close();
PopulateTable(state);
return state.Table;
}
/// <summary>
/// Populate the Slice table
/// </summary>
/// <param name="state">
/// The State object that contains the data that will be used to populate the slice table
/// </param>
protected static void PopulateTable(RendererState state)
{
state.Table.Add(state.HorizontalOrderedRows);
if (state.VerticalKeyTitles.Children.Count > 0 && state.VerticalOrderedRows.Count > 0)
{
int dataLength = state.VerticalOrderedRows[0].Children.Count - state.VerticalKeyTitles.Children.Count;
var empty = new TableCell();
empty.SetColSpan(dataLength);
state.VerticalKeyTitles.AddElement(empty);
state.Table.AddElement(state.VerticalKeyTitles);
}
state.VerticalOrderedRows.Sort(new VerticalKeyComparer(state.Model.VerticalKeys.Count));
SetupVerticalRowSpan(state);
state.Table.Add(state.VerticalOrderedRows);
}
/// <summary>
/// Commit the current table and reset state
/// </summary>
/// <param name="state">
/// The state
/// </param>
/// <param name="doc">
/// The pdf document to commit the current table
/// </param>
private static void CommitTable(RendererState state, IDocListener doc)
{
if (state.Table != null)
{
PopulateTable(state);
// containerTable.Write(writer);
PdfPTable table = CreatePdf(state.Table);
if (table != null)
{
doc.Add(table);
table.DeleteBodyRows();
}
doc.NewPage();
state.Reset();
}
}
private void beginSpriteBatch()
{
if (state != RendererState.SpriteBatchBegan)
{
if (state == RendererState.SkeletonRendererBegan)
skeletonRenderer.End();
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, null, null, null, CurrentShader);
state = RendererState.SpriteBatchBegan;
}
}
/// <summary>
/// Set vertical row span in <see cref="RendererState.VerticalOrderedRows"/>.
/// </summary>
/// <param name="s">
/// The <see cref="RendererState"/> containing the vertical ordered rows
/// </param>
private static void SetupVerticalRowSpan(RendererState s)
{
try
{
int keyCount = s.Model.VerticalKeys.Count - 1;
if (keyCount < 1)
{
// we don't care about colspan if there is only one or less vertical keys
return;
}
// The TD per TR that will be deleted
var toDeleteTableCells = new Dictionary<TableRow, List<TableCell>>();
// the previous row values
var previousValues = new string[keyCount];
var firstTableCell = new TableCell[keyCount];
for (int v = 0; v < s.VerticalOrderedRows.Count; v++)
{
// for each TR row
var row = s.VerticalOrderedRows[v];
for (int i = 0; i < keyCount; i++)
{
// for each vertical key column
TableCell cell = row.Children[i];
string cell_value = string.Empty;
cell_value = HtmlRenderer.GetSdmxValue(cell);
if (cell != null && !string.Equals(cell_value, previousValues[i]))
{
// if the current key value doesn't equal the previous row value
previousValues[i] = cell_value; // set the previous value to the current
for (int x = i + 1; x < keyCount; x++)
{
// reset any previous values from keys that follow the current
previousValues[x] = null;
}
firstTableCell[i] = cell;
}
else
{
firstTableCell[i].RowSpan++;
List<TableCell> deleteList;
if (!toDeleteTableCells.TryGetValue(row, out deleteList))
{
deleteList = new List<TableCell>();
toDeleteTableCells.Add(row, deleteList);
}
deleteList.Add(cell);
}
}
}
foreach (KeyValuePair<TableRow, List<TableCell>> entry in toDeleteTableCells)
{
foreach (TableCell cell in entry.Value)
{
entry.Key.Children.Remove(cell);
}
}
}
catch(Exception ex) {
}
}
/// <summary>
/// Write all data splitted in slices to the specified writer
/// </summary>
/// <param name="model">
/// The model to write
/// </param>
/// <param name="writer">
/// The writer to use
/// </param>
protected virtual void WriteTableModels(IDataSetModel model, TextWriter writer)
{
IDataReader allData = model.GetReader(false);
Table containerTable = CreateContainerTable();
string oldKeySet = null;
var s = new RendererState(model);
while (allData.Read())
{
s.InputRow = allData;
string currentKeySet = MakeKey(model.SliceKeys, allData);
if (!currentKeySet.Equals(oldKeySet))
{
oldKeySet = currentKeySet;
if (s.Table != null)
{
PopulateTable(s);
containerTable.Write(writer);
s.Reset();
}
containerTable = CreateContainerTable();
Table sliceHeaderTable = this.CreateSliceHeaderTable(s);
AddSliceHeading(containerTable, sliceHeaderTable);
s.Table = CreateSliceTable();
AddSliceTable(containerTable, s.Table);
this.InitTitles(s);
}
this.ParseDataRow(s);
}
allData.Close();
s.InputRow = null;
if (s.Table != null)
{
PopulateTable(s);
containerTable.Write(writer);
s.Reset();
}
}
/// <summary>
/// Parse a data row and populate the <see cref="RendererState.CurrentTableRow"/> with the X, Y axis key values and the data
/// </summary>
/// <param name="state">
/// The current state
/// </param>
protected virtual void ParseDataRow(RendererState state, object vc = null, object vt = null)
{
#region check if something has changed
state.HorizontalCurrentKeySet = MakeKey(state.Model.HorizontalKeys, state.InputRow);
if (!string.Equals(state.HorizontalCurrentKeySet, state.HorizontalOldKeySet))
{
state.CurrentHorizontalKeySetColumn++;
state.HorizontalOldKeySet = state.HorizontalCurrentKeySet;
foreach (TableRow row in state.VerticalKeySetIndex.Values)
{
TableCell emptyMeasure = new TableCell("-");
emptyMeasure.AddClass(HtmlClasses.NotMeasure);
row.AddElement(emptyMeasure);
}
foreach (string dim in state.Model.HorizontalKeys)
{
TableRow horizontalKeyRow = state.HorizontalKeyRows[dim];
var currentValue = state.InputRow[dim] as string;
this.AddHorrizontalKeyValues(
state.VerticalPreviousValuesMap,
dim,
horizontalKeyRow,
currentValue,
state.Model,
state.InputRow);
}
}
#endregion
TableRow currentRow;
state.VerticalCurrentKeySet = MakeKey(state.Model.VerticalKeys, state.InputRow);
if (!state.VerticalKeySetIndex.TryGetValue(state.VerticalCurrentKeySet, out currentRow))
{
state.CurrentTableRow = new TableRow();
if (state.Model.VerticalKeys.Count == 0 && state.Model.HorizontalKeys.Count > 0)
{
TableCell emptyMeasure = new TableCell("-");
emptyMeasure.AddClass(HtmlClasses.NotMeasure);
state.CurrentTableRow.AddElement(emptyMeasure);
}
state.VerticalKeySetIndex.Add(state.VerticalCurrentKeySet, state.CurrentTableRow);
state.VerticalOrderedRows.Add(state.CurrentTableRow);
foreach (string dim in state.Model.VerticalKeys)
{
var currentValue = state.InputRow[dim] as string;
this.AddVerticalKeyValues(
state.HorizontalPreviousValuesMap,
dim,
state.CurrentTableRow,
currentValue,
state.Model,
state.InputRow);
}
int currentVerticalKeyValueCount = state.CurrentTableRow.Children.Count;
state.VerticalKeyValueCount.Add(state.VerticalCurrentKeySet, currentVerticalKeyValueCount);
state.CurrentVerticalKeyValueCount = currentVerticalKeyValueCount;
for (int i = 0; i < state.CurrentHorizontalKeySetColumn; i++)
{
TableCell emptyMeasure = new TableCell("-");
emptyMeasure.AddClass(HtmlClasses.NotMeasure);
state.CurrentTableRow.AddElement(emptyMeasure);
}
}
else
{
state.CurrentTableRow = currentRow;
state.CurrentVerticalKeyValueCount = state.VerticalKeyValueCount[state.VerticalCurrentKeySet];
}
//var time = state.InputRow[state.Model.KeyFamily.TimeDimension.Id] as string;
NumberStyles style;
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands | NumberStyles.AllowLeadingSign;
var val = state.InputRow[state.Model.KeyFamily.PrimaryMeasure.Id] as string;
if (string.IsNullOrEmpty(val)
|| val == "NaN")
{
val = string.Empty;
}
else {
decimal decVal = 0;
Int32 intVal = 0;
if (Int32.TryParse(val.ToString(), out intVal))
{
val = intVal.ToString();
}
else if (decimal.TryParse(val.ToString(), style, cFrom, out decVal))
{
val = decVal.ToString("F1", cTo);
}
}
TableCell data_cell;
if (string.IsNullOrEmpty(val))
{
data_cell = new TableCell("-");
data_cell.AddClass(HtmlClasses.NotMeasure);
}else{
this._uniqID++;
Table tb = new Table();
TableRow _rw = new TableRow();
// Add table info extra at level observation
Table tb_extra =
(this._useSdmxAttr) ?
(!string.IsNullOrEmpty(val)) ?
CreateObservationAttribute(state.Model, state.InputRow) : null : null;
if (tb_extra != null)
{
tb_extra.AddAttribute("ID", this._uniqID + "_info_extra_dialog");
tb_extra.AddClass(HtmlClasses.ExtraInfoTable);
tb.AddRow(new TableRow(new TableCell(tb_extra)));
var tb_btn_extra = new TableCell();
tb_btn_extra.AddClass(HtmlClasses.ExtraInfoWrapper);
tb_btn_extra.AddAttribute("ID", this._uniqID + "_info");
_rw.AddCell(tb_btn_extra);
}
/*
decimal decVal_vc = 0;
if (vc != null && decimal.TryParse(vc.ToString(), NumberStyles.AllowDecimalPoint, cFrom, out decVal_vc))
{
vc = decVal_vc.ToString("F1", cTo);
}
decimal decVal_vt = 0;
if (vt != null && decimal.TryParse(vt.ToString(), NumberStyles.AllowDecimalPoint, cFrom, out decVal_vt))
{
vt = decVal_vt.ToString("F1", cTo);
}
*/
TableCell measure = new TableCell((string.IsNullOrEmpty(val)) ? "-" : val);
measure.AddClass((string.IsNullOrEmpty(val)) ? HtmlClasses.NotMeasure : HtmlClasses.Measure);
measure.AddAttribute("data-v", (string.IsNullOrEmpty(val)) ? "-" : val);
measure.AddAttribute("data-vc", (vc == null) ? "?" : vc.ToString());
measure.AddAttribute("data-vt", (vt == null) ? "?" : vt.ToString());
_rw.AddCell(measure);
tb.AddRow(_rw);
data_cell = new TableCell(tb);
data_cell.AddClass(HtmlClasses.ExtraInfoTableValue);
}
int column = state.CurrentHorizontalKeySetColumn + state.CurrentVerticalKeyValueCount;
state.CurrentTableRow.AddAt(data_cell, column);
}
/// <summary>
/// Initialize the horizontal and vertical key titles
/// </summary>
/// <param name="state">
/// The current <see cref="RendererState"/>
/// </param>
protected void InitTitles(RendererState state)
{
state.VerticalKeyTitles = this.CreateVerticalTitles(state.Model);
// There will be exactly one row for each horizontal dimension (for both title & possible values)...
this.CreateHorizontalTitles(state.Model, state.HorizontalKeyRows, state.HorizontalOrderedRows);
}
/// <summary>
/// Create a slice header table that will contain the slice key titles and values
/// </summary>
/// <param name="state">
/// The current state
/// </param>
/// <returns>
/// The slice header table
/// </returns>
protected Table CreateSliceHeaderTable(RendererState state)
{
var table = new Table();
table.AddClass(HtmlClasses.SliceKeys);
table.AddAttribute(HtmlConstants.CellPadding, ZeroValue);
table.AddAttribute(HtmlConstants.CellSpacing, ZeroValue);
foreach (string key in state.Model.SliceKeys)
{
var row = new TableRow();
table.AddElement(row);
var value = state.InputRow[key] as string;
value = value ?? " ";
var title = new TableCell(state.Model.AllValidKeys[key]);
title.AddClass(HtmlClasses.SliceKeyTitle);
row.AddElement(title);
string text = this.GetLocalizedName(key, value);
var val = new TableCell();
// Implemented like in java to show description only
val.SetupDisplayText(value, text, key, DisplayMode.Description, false);
val.AddClass(HtmlClasses.SliceKeyValue);
row.AddElement(val);
}
return table;
}
/// <summary>
/// Write all data splitted in slices to the specified writer
/// </summary>
/// <param name="model">
/// The model to write
/// </param>
/// <param name="writer">
/// The writer to use
/// </param>
protected override void WriteTableModels(IDataSetModel model, TextWriter writer)
{
IDataReader allData = model.GetReader(false);
string oldKeySetSlice = null;
var s = new RendererState(model);
while (allData.Read())
{
s.InputRow = allData;
string currentKeySet = MakeKey(model.SliceKeys, allData);
if (!currentKeySet.Equals(oldKeySetSlice))
{
oldKeySetSlice = currentKeySet;
this.CommitTable(s, writer);
Table sliceHeaderTable = this.CreateSliceHeaderTable(s);
sliceHeaderTable.WriteCsv(writer, this._separator);
s.Table = CreateSliceTable();
this.InitTitles(s);
}
this.ParseDataRow(s);
}
allData.Close();
s.InputRow = null;
this.CommitTable(s, writer);
}
public void Push()
{
if (states.Count >= 10)
{
throw new Exception("Maximum amount (10) of saved states was reached.");
}
RendererState s = new RendererState();
//states
s.IsDrawing = IsDrawing;
s.IsScaled = IsScaeld;
//stencil
s.s1 = s1;
s.s2 = s2;
s.a = a;
s.MaskBeingDrawnOn = IsMaskBeingDrawnOn;
s.MaskBeingUsed = IsMaskBeingUsed;
//FBO
s.FBO = curFBO;
//overlay
s.Overlay = Overlay;
states.Add(s);
}
/// <summary>
/// Write all data splitted in slices to the specified writer
/// </summary>
/// <param name="model">
/// The dataset model
/// </param>
/// <param name="doc">
/// The PDF document
/// </param>
private void WriteTableModels(IDataSetModel model, IDocListener doc)
{
IDataReader reader = model.GetReader(false);
// DIV containerTable = createContainerTable();
string oldKeySet = null;
var s = new RendererState(model);
while (reader.Read())
{
s.InputRow = reader;
string currentKeySet = MakeKey(model.SliceKeys, reader);
if (!currentKeySet.Equals(oldKeySet))
{
oldKeySet = currentKeySet;
CommitTable(s, doc);
// containerTable = createContainerTable();
this.CreateSliceHeader(doc, s);
// addSliceHeading(containerTable, sTable);
s.Table = CreateSliceTable();
// addSliceTable(containerTable, s.table);
this.InitTitles(s);
}
this.ParseDataRow(s);
}
reader.Close();
s.InputRow = null;
CommitTable(s, doc);
}
/// <summary>
/// Create the slice header
/// </summary>
/// <param name="doc">
/// The <see cref="Document"/>
/// </param>
/// <param name="state">
/// The current <see cref="HtmlRenderer.RendererState"/>
/// </param>
private void CreateSliceHeader(IElementListener doc, RendererState state)
{
Table headerTable = this.CreateSliceHeaderTable(state);
PdfPTable table = CreatePdf(headerTable);
if (table != null)
{
doc.Add(table);
table.DeleteBodyRows();
}
}
/// <summary>
/// Render to the specified writer the current slide as a html table
/// </summary>
/// <param name="model">
/// The model to render
/// </param>
/// <param name="os">
/// The output to write to
/// </param>
public virtual void Render(IDataSetModel model, TextWriter os)
{
var s = new RendererState(model);
Table table = this.CreateTableModel(s);
// Table table = this.createTableModel(model);
table.Write(os);
}
private void beginSkeletonRenderer()
{
if (state != RendererState.SkeletonRendererBegan)
{
if (state == RendererState.SpriteBatchBegan)
spriteBatch.End();
skeletonRenderer.Begin(CurrentShader);
state = RendererState.SkeletonRendererBegan;
}
}
public void End()
{
if (state == RendererState.SpriteBatchBegan)
spriteBatch.End();
else if (state == RendererState.SkeletonRendererBegan)
skeletonRenderer.End();
state = RendererState.NoneBegan;
}
protected void ChangeState(RendererState expectedState, RendererState newState)
{
lock (_stateLock)
{
if (_state == expectedState)
{
_state = newState;
}
}
}
protected void ChangeState(RendererState newState)
{
lock (_stateLock)
{
_state = newState;
}
}
