Exemple #1
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new InvalidOperationException("Serialization of old version");

                /*
                 *                      ImageGraphic s = (ImageGraphic)obj;
                 *                      info.AddBaseValueEmbedded(s, typeof(ImageGraphic).BaseType);
                 *
                 *                      info.AddValue("SizeBasedOnSourceSize", s._isSizeCalculationBasedOnSourceSize);
                 *                      info.AddEnum("AspectPreserving", s._aspectPreserving);
                 */
            }
Exemple #2
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new NotImplementedException("Serialization of old versions not supported");

                /*
                 *                      XYLineScatterPlotStyle s = (XYLineScatterPlotStyle)obj;
                 *                      info.AddValue("XYPlotLineStyle",s.m_LineStyle);
                 *                      info.AddValue("XYPlotScatterStyle",s.m_ScatterStyle);
                 *                      info.AddValue("LineSymbolGap",s.m_LineSymbolGap);
                 *                      info.AddValue("LabelStyle",s.m_LabelStyle);      // new in this version
                 */
            }
Exemple #3
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (EmbeddedObjectRenderingOptions)obj;

                info.AddValue("SourceResolution", s._sourceDpiResolution);
                info.AddValue("BackgroundForFormatsWithoutAlphaChannel", s._backgroundColorForFormatsWithoutAlphaChannel);
                info.AddValue("BackgroundBrush", s._backgroundBrush);
                info.AddValue("RenderEnhancedMetafile", s._renderEnhancedMetafile);
                info.AddValue("RenderEnhancedMetafileAsVectorFormat", s._renderEnhancedMetafileAsVectorFormat);
                info.AddValue("RenderWindowsMetafile", s._renderWindowsMetafile);
                info.AddValue("RenderBitmap", s._renderBitmap);
            }
Exemple #4
0
            public override void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new NotSupportedException("Serialization of old versions is not supported, probably a programming error");

                /*
                 * base.Serialize(obj, info);
                 * XYPlotScatterStyle s = (XYPlotScatterStyle)obj;
                 * info.AddValue("IndependentColor", s._independentColor);
                 * info.AddValue("IndependentSymbolSize", s._independentSymbolSize);
                 * info.AddValue("SkipFreq", s._skipFreq);
                 */
            }
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (DateTimeLabelFormatting)obj;

                info.AddBaseValueEmbedded(s, typeof(MultiLineLabelFormattingBase));

                info.AddEnum("TimeConversion", s._timeConversion);
                info.AddValue("FormatString", s._formatString);
                info.AddValue("ShowAlternateFormattingAtMidnight", s._showAlternateFormattingAtMidnight);
                info.AddValue("ShowAlternateFormattingAtNoon", s._showAlternateFormattingAtNoon);
                info.AddValue("FormatStringAlternate", s._formatStringAlternate);
            }
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                DensityImagePlotStyle s = (DensityImagePlotStyle)obj;

                info.AddEnum("ScalingStyle", s.m_ScalingStyle);
                info.AddValue("RangeFrom", s.m_RangeFrom);
                info.AddValue("RangeTo", s.m_RangeTo);
                info.AddValue("ClipToLayer", s.m_ClipToLayer);
                info.AddValue("ColorBelow", s.m_ColorBelow);
                info.AddValue("ColorAbove", s.m_ColorAbove);
                info.AddValue("ColorInvalid", s.m_ColorInvalid);
            }
Exemple #7
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (ProductFunction)obj;

                info.AddArray("Coefficients", s._coefficients, s._coefficients.Length);
                info.CreateArray("Functions", s._functions.Length);
                for (int i = 0; i < s._functions.Length; i++)
                {
                    info.AddValue("e", s._functions[i]);
                }
                info.CommitArray();
            }
Exemple #8
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new InvalidOperationException("Serialization of old versions not supported.");

                /*
                 *                      LinkedScale s = (LinkedScale)obj;
                 *
                 *                      info.AddValue("ScaleWrapped", s._scaleWrapped);
                 *                      info.AddValue("LinkParameters", s._linkParameters);
                 *                      info.AddValue("LinkedScaleIndex", s._linkedScaleIndex);
                 */
            }
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (RangeOfNumericalValues)obj;

                info.AddValue("LowerValue", (object)s._lowerValue);
                info.AddValue("LowerIsInclusive", s._isLowerInclusive);

                info.AddValue("UpperValue", (object)s._upperValue);
                info.AddValue("UpperIsInclusive", s._isUpperInclusive);

                info.AddValue("Column", s._columnProxy);
            }
Exemple #10
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (HavriliakNegamiSusceptibility)obj;

                info.AddValue("UseFrequency", s._useFrequencyInsteadOmega);
                info.AddValue("FlowTerm", s._useFlowTerm);
                info.AddValue("IsDielectric", s._isDielectricData);
                info.AddValue("InvertViscosity", s._invertViscosity);
                info.AddValue("NumberOfRelaxations", s._numberOfTerms);
                info.AddValue("InvertResult", s._invertResult);
                info.AddValue("LogarithmizeResults", s._logarithmizeResults);
            }
Exemple #11
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new InvalidOperationException("Serialization of old version");

                /*
                 *                      ScaleCollection s = (ScaleCollection)obj;
                 *
                 *                      info.CreateArray("Members", s._scales.Length);
                 *                      for (int i = 0; i < s._scales.Length; ++i)
                 *                              info.AddValue("e", s._scales[i]);
                 *                      info.CommitArray();
                 */
            }
Exemple #12
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                DateTimeScale s = (DateTimeScale)obj;


                info.AddValue("Org", s._axisOrg);
                info.AddValue("End", s._axisEnd);
                info.AddEnum("MajorSpanUnit", s._majorSpan._unit);
                info.AddValue("MajorSpanValue", s._majorSpan._span);
                info.AddValue("MinorTicks", s._minorTicks);
                info.AddValue("Bounds", s._dataBounds);
                info.AddValue("Rescaling", s._rescaling);
            }
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (ColumnDrivenColorPlotStyle)obj;

                info.AddValue("DataColumn", s._dataColumnProxy);
                info.AddValue("Scale", s._scale);

                info.AddValue("ColorProvider", s._colorProvider);

                info.AddValue("AppliesToFill", s._appliesToFill);
                info.AddValue("AppliesToStroke", s._appliesToStroke);
                info.AddValue("AppliesToBackground", s._appliesToBackground);
            }
Exemple #14
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (Log10Scale)obj;

                info.AddValue("Log10Org", s._log10Org);
                info.AddValue("Log10End", s._log10End);
                info.AddValue("DecadesPerMajor", s._decadesPerMajorTick);

                //info.AddValue("OrgFixed",s.m_AxisOrgFixed);
                //info.AddValue("EndFixed",s.m_AxisEndFixed);

                info.AddValue("Bounds", s._dataBounds);
            }
Exemple #15
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (ColorGroupStyle)obj;

                info.AddValue("StepEnabled", s._isStepEnabled);
                info.AddValue("ColorSet", s._listOfValues);
                info.AddValue("ColorIndex", s._colorIndex);

                if (s._isLocalGroupStyle)
                {
                    throw new ArgumentOutOfRangeException("Trying to serialize a local ColorPlotGroupStyle is not allowed. Please report this bug to the forum.");
                }
            }
Exemple #16
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                DocumentPath s = (DocumentPath)obj;

                info.AddValue("IsAbsolute", s._IsAbsolutePath);

                info.CreateArray("Path", s.Count);
                for (int i = 0; i < s.Count; i++)
                {
                    info.AddValue("e", s[i]);
                }
                info.CommitArray();
            }
Exemple #17
0
            public override void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new InvalidOperationException("Serialization of old version");

                /*
                 *                      base.Serialize(obj, info);
                 *                      GraphDocument s = (GraphDocument)obj;
                 *                      info.AddValue("GraphIdentifier", s._graphIdentifier);
                 *                      info.AddValue("Notes", s._notes.Text);
                 *                      info.AddValue("CreationTime", s._creationTime.ToLocalTime());
                 *                      info.AddValue("LastChangeTime", s._lastChangeTime.ToLocalTime());
                 */
            }
Exemple #18
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (SpotLight)obj;

                info.AddValue("IsAffixedToCamera", s._isAffixedToCamera);
                info.AddValue("LightAmplitude", s._lightAmplitude);
                info.AddValue("Color", s._color);
                info.AddValue("Position", s._position);
                info.AddValue("DirectionToLight", s._directionToLight);
                info.AddValue("Range", s._range);
                info.AddValue("OuterConeAngle", s._outerConeAngle);
                info.AddValue("InnerConeAngle", s._innerConeAngle);
            }
        public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
        {
            var s = (System.Collections.Generic.List <object>)obj;

            info.CreateArray("List", s.Count);

            for (int i = 0; i < s.Count; ++i)
            {
                info.AddValue("e", s[i]);
            }

            info.CommitArray();
        }
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                XYColumnPlotData s = (XYColumnPlotData)obj;

                info.AddValue("XColumn", s._xColumn);
                info.AddValue("YColumn", s._yColumn);

                info.AddValue("XBoundaries", s._xBoundaries);
                info.AddValue("YBoundaries", s._yBoundaries);

                info.AddValue("RangeStart", s._plotRangeStart);
                info.AddValue("RangeLength", s._plotRangeLength);
            }
Exemple #21
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (GraphDocument)obj;

                info.AddValue("Name", s._name);
                info.AddValue("GraphIdentifier", s._graphIdentifier);
                info.AddValue("CreationTime", s._creationTime.ToLocalTime());
                info.AddValue("LastChangeTime", s._lastChangeTime.ToLocalTime());
                info.AddValue("Notes", s._notes.Text);
                info.AddValue("RootLayer", s._rootLayer);

                info.AddValue("Properties", s._graphProperties);
            }
Exemple #22
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new InvalidOperationException("Serialization of old version not supported");

                /*
                 *                      DocNodeProxy s = (DocNodeProxy)obj;
                 *
                 *                      if (null != s.InternalDocNode)
                 *                              info.AddValue("Node", Main.DocumentPath.GetAbsolutePath(s.InternalDocumentObject));
                 *                      else if (s._docNodePath != null)
                 *                              info.AddValue("Node", s._docNodePath);
                 */
            }
Exemple #23
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (NumericalBoundaries)obj;

                if ((s._minValue == double.MaxValue || s._maxValue == double.MinValue) && s._numberOfItems != 0)
                {
                    throw new InvalidOperationException(string.Format("Type {0} has NumberOfItems={1}, but MinValue is {2} and MaxValue is {3}", s.GetType(), s._numberOfItems, s._minValue, s._maxValue));
                }

                info.AddValue("NumberOfItems", s._numberOfItems);
                info.AddValue("MinValue", s._minValue);
                info.AddValue("MaxValue", s._maxValue);
            }
        public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
        {
            var s = (UnitWithLimitedPrefixes)obj;

            info.AddValue("Unit", s.Unit);

            info.CreateArray("PrefixList", s.Prefixes.Count);
            foreach (var prefix in s.Prefixes)
            {
                info.AddValue("e", prefix);
            }
            info.CommitArray();
        }
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (IntersectionOfRowSelections)obj;

                info.CreateArray("RowSelections", s._rowSelections.Count);

                for (int i = 0; i < s._rowSelections.Count; ++i)
                {
                    info.AddValue("e", s._rowSelections[i]);
                }

                info.CommitArray();
            }
Exemple #26
0
            public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new InvalidOperationException("Serialization of old version");

                /*
                 *                      DateTimeScale s = (DateTimeScale)obj;
                 *
                 *                      info.AddValue("Org", s._axisOrg);
                 *                      info.AddValue("End", s._axisEnd);
                 *                      info.AddValue("Rescaling", s._rescaling);
                 *                      info.AddValue("Bounds", s._dataBounds);
                 */
            }
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                throw new NotSupportedException("Serialization of old versions is not supported");

                /*
                 * G2DPlotStyleCollection s = (G2DPlotStyleCollection)obj;
                 *
                 * info.CreateArray("Styles", s._innerList.Count);
                 * for (int i = 0; i < s._innerList.Count; i++)
                 * info.AddValue("e", s._innerList[i]);
                 * info.CommitArray();
                 */
            }
Exemple #28
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (ShapeGroup)obj;

                info.AddBaseValueEmbedded(s, typeof(ShapeGroup).BaseType);

                info.CreateArray("Elements", s._groupedObjects.Count);
                foreach (var e in s._groupedObjects)
                {
                    info.AddValue("e", e);
                }
                info.CommitArray();
            }
Exemple #29
0
            public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
            {
                var s = (DensityImageLegend)obj;

                info.AddBaseValueEmbedded(s, typeof(DensityImageLegend).BaseType);

                info.AddValue("PlotItem", s._plotItemProxy);
                info.AddValue("IsOrientationVertical", s.IsOrientationVertical);
                info.AddValue("IsScaleReversed", s.IsScaleReversed);
                info.AddValue("Scale", s.ScaleWithTicks);
                info.AddValue("TickSpacing", s.ScaleWithTicks.TickSpacing);
                info.AddValue("AxisStyles", s._axisStyles);
            }
Exemple #30
0
                public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
                {
                    var s = (StateMemento)obj;

                    info.CreateArray("ColumnWidths", s.ColumnWidths.Length);

                    foreach (var w in s.ColumnWidths)
                    {
                        info.AddValue("e", w);
                    }

                    info.CommitArray();
                }