Free cookie consent management tool by TermsFeed Policy Generator

Changeset 5611


Ignore:
Timestamp:
03/04/11 23:59:11 (12 years ago)
Author:
swagner
Message:

Worked on OKB (#1174)

Location:
branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query/QueryClient.cs

    r5606 r5611  
    2222using System;
    2323using System.Collections.Generic;
    24 using System.IO;
    2524using System.Linq;
    2625using HeuristicLab.Clients.Common;
    27 using HeuristicLab.Collections;
    2826using HeuristicLab.Common;
    2927using HeuristicLab.Core;
    30 using HeuristicLab.Data;
    31 using HeuristicLab.Optimization;
    32 using HeuristicLab.Persistence.Default.Xml;
    33 using HeuristicLab.PluginInfrastructure;
    3428
    3529namespace HeuristicLab.Clients.OKB.Query {
     
    4539
    4640    #region Properties
    47     private ItemCollection<Platform> platforms;
    48     public ItemCollection<Platform> Platforms {
    49       get { return platforms; }
    50     }
    51     private ItemCollection<DataType> dataTypes;
    52     public ItemCollection<DataType> DataTypes {
    53       get { return dataTypes; }
    54     }
    55     private IEnumerable<User> users;
    56     public IEnumerable<User> Users {
    57       get { return users; }
    58     }
    59     private ItemCollection<AlgorithmClass> algorithmClasses;
    60     public ItemCollection<AlgorithmClass> AlgorithmClasses {
    61       get { return algorithmClasses; }
    62     }
    63     private ItemCollection<Algorithm> algorithms;
    64     public ItemCollection<Algorithm> Algorithms {
    65       get { return algorithms; }
    66     }
    67     private ItemCollection<ProblemClass> problemClasses;
    68     public ItemCollection<ProblemClass> ProblemClasses {
    69       get { return problemClasses; }
    70     }
    71     private ItemCollection<Problem> problems;
    72     public ItemCollection<Problem> Problems {
    73       get { return problems; }
     41    private List<Filter> filters;
     42    public IEnumerable<Filter> Filters {
     43      get { return filters; }
    7444    }
    7545    #endregion
    7646
    7747    private QueryClient() {
    78       platforms = new ItemCollection<Platform>();
    79       platforms.ItemsRemoved += new CollectionItemsChangedEventHandler<Platform>(platforms_ItemsRemoved);
    80       dataTypes = new ItemCollection<DataType>();
    81       dataTypes.ItemsRemoved += new CollectionItemsChangedEventHandler<DataType>(dataTypes_ItemsRemoved);
    82       algorithmClasses = new ItemCollection<AlgorithmClass>();
    83       algorithmClasses.ItemsRemoved += new CollectionItemsChangedEventHandler<AlgorithmClass>(algorithmClasses_ItemsRemoved);
    84       algorithms = new ItemCollection<Algorithm>();
    85       algorithms.ItemsRemoved += new CollectionItemsChangedEventHandler<Algorithm>(algorithms_ItemsRemoved);
    86       problemClasses = new ItemCollection<ProblemClass>();
    87       problemClasses.ItemsRemoved += new CollectionItemsChangedEventHandler<ProblemClass>(problemClasses_ItemsRemoved);
    88       problems = new ItemCollection<Problem>();
    89       problems.ItemsRemoved += new CollectionItemsChangedEventHandler<Problem>(problems_ItemsRemoved);
     48      filters = new List<Filter>();
    9049    }
    9150
     
    9352    public void Refresh() {
    9453      OnRefreshing();
    95 
    96       platforms.Clear();
    97       dataTypes.Clear();
    98       algorithmClasses.Clear();
    99       algorithms.Clear();
    100       problemClasses.Clear();
    101       problems.Clear();
    102 
     54      filters = new List<Filter>();
     55      try {
     56        filters.AddRange(CallQueryService<List<Filter>>(s => s.GetFilters()));
     57      }
     58      finally {
     59        OnRefreshed();
     60      }
     61    }
     62    public void RefreshAsync(Action<Exception> exceptionCallback) {
    10363      var call = new Func<Exception>(delegate() {
    10464        try {
    105           platforms.AddRange(CallAdministrationService<List<Platform>>(s => s.GetPlatforms()).OrderBy(x => x.Name));
    106           dataTypes.AddRange(CallAdministrationService<List<DataType>>(s => s.GetDataTypes()).OrderBy(x => x.Name));
    107           users = CallAuthenticationService<List<User>>(s => s.GetUsers()).OrderBy(x => x.Name);
    108           algorithmClasses.AddRange(CallAdministrationService<List<AlgorithmClass>>(s => s.GetAlgorithmClasses()).OrderBy(x => x.Name));
    109           algorithms.AddRange(CallAdministrationService<List<Algorithm>>(s => s.GetAlgorithms()).OrderBy(x => x.Name));
    110           problemClasses.AddRange(CallAdministrationService<List<ProblemClass>>(s => s.GetProblemClasses()).OrderBy(x => x.Name));
    111           problems.AddRange(CallAdministrationService<List<Problem>>(s => s.GetProblems()).OrderBy(x => x.Name));
    112           return null;
     65          Refresh();
    11366        }
    11467        catch (Exception ex) {
    11568          return ex;
    11669        }
     70        return null;
    11771      });
    11872      call.BeginInvoke(delegate(IAsyncResult result) {
    11973        Exception ex = call.EndInvoke(result);
    120         if (ex != null) ErrorHandling.ShowErrorDialog("Refresh failed.", ex);
    121         OnRefreshed();
     74        if (ex != null) exceptionCallback(ex);
    12275      }, null);
    12376    }
    12477    #endregion
    12578
    126     #region Store
    127     public bool Store(IOKBItem item) {
    128       try {
    129         if (item.Id == 0) {
    130           if (item is Platform)
    131             item.Id = CallAdministrationService<long>(s => s.AddPlatform((Platform)item));
    132           else if (item is DataType)
    133             item.Id = CallAdministrationService<long>(s => s.AddDataType((DataType)item));
    134           else if (item is AlgorithmClass)
    135             item.Id = CallAdministrationService<long>(s => s.AddAlgorithmClass((AlgorithmClass)item));
    136           else if (item is Algorithm)
    137             item.Id = CallAdministrationService<long>(s => s.AddAlgorithm((Algorithm)item));
    138           else if (item is AlgorithmParameter)
    139             item.Id = CallAdministrationService<long>(s => s.AddAlgorithmParameter((AlgorithmParameter)item));
    140           else if (item is ProblemClass)
    141             item.Id = CallAdministrationService<long>(s => s.AddProblemClass((ProblemClass)item));
    142           else if (item is Problem)
    143             item.Id = CallAdministrationService<long>(s => s.AddProblem((Problem)item));
    144           else if (item is ProblemParameter)
    145             item.Id = CallAdministrationService<long>(s => s.AddProblemParameter((ProblemParameter)item));
    146           else if (item is Result)
    147             item.Id = CallAdministrationService<long>(s => s.AddResult((Result)item));
    148           else if (item is Experiment)
    149             item.Id = CallAdministrationService<long>(s => s.AddExperiment((Experiment)item));
    150           else if (item is Run)
    151             item.Id = CallAdministrationService<long>(s => s.AddRun((Run)item));
    152         } else {
    153           if (item is Platform)
    154             CallAdministrationService(s => s.UpdatePlatform((Platform)item));
    155           else if (item is DataType)
    156             CallAdministrationService(s => s.UpdateDataType((DataType)item));
    157           else if (item is AlgorithmClass)
    158             CallAdministrationService(s => s.UpdateAlgorithmClass((AlgorithmClass)item));
    159           else if (item is Algorithm)
    160             CallAdministrationService(s => s.UpdateAlgorithm((Algorithm)item));
    161           else if (item is AlgorithmParameter)
    162             CallAdministrationService(s => s.UpdateAlgorithmParameter((AlgorithmParameter)item));
    163           else if (item is ProblemClass)
    164             CallAdministrationService(s => s.UpdateProblemClass((ProblemClass)item));
    165           else if (item is Problem)
    166             CallAdministrationService(s => s.UpdateProblem((Problem)item));
    167           else if (item is ProblemParameter)
    168             CallAdministrationService(s => s.UpdateProblemParameter((ProblemParameter)item));
    169           else if (item is Result)
    170             CallAdministrationService(s => s.UpdateResult((Result)item));
    171           else if (item is Experiment)
    172             item.Id = CallAdministrationService<long>(s => s.AddExperiment((Experiment)item));
    173           else if (item is Run)
    174             item.Id = CallAdministrationService<long>(s => s.AddRun((Run)item));
    175         }
    176         return true;
    177       }
    178       catch (Exception ex) {
    179         ErrorHandling.ShowErrorDialog("Store failed.", ex);
    180         return false;
    181       }
     79    #region Query Methods
     80    public long GetNumberOfRuns(Filter filter) {
     81      return CallQueryService<long>(x => x.GetNumberOfRuns(filter));
    18282    }
    183     #endregion
    184 
    185     #region DataType Methods
    186     public DataType ConvertToDataType(Type type) {
    187       DataType dataType = DataTypes.FirstOrDefault(x => x.TypeName == type.AssemblyQualifiedName);
    188       if (dataType == null) {
    189         dataType = new DataType();
    190         dataType.Name = type.Name;
    191         dataType.TypeName = type.AssemblyQualifiedName;
    192         dataType.PlatformId = Platforms.FirstOrDefault(x => x.Name == "HeuristicLab 3.3").Id;
    193 
    194         if (typeof(BoolValue).IsAssignableFrom(type))
    195           dataType.SqlName = "bit";
    196         else if (typeof(IntValue).IsAssignableFrom(type))
    197           dataType.SqlName = "bigint";
    198         else if (typeof(DoubleValue).IsAssignableFrom(type))
    199           dataType.SqlName = "float";
    200         else if (typeof(StringValue).IsAssignableFrom(type) || typeof(IStringConvertibleValue).IsAssignableFrom(type))
    201           dataType.SqlName = "nvarchar";
    202         else
    203           dataType.SqlName = "varbinary";
    204 
    205         dataType.Store();
    206         DataTypes.Add(dataType);
    207       }
    208       return dataType;
     83    public IEnumerable<long> GetRunIds(Filter filter) {
     84      return CallQueryService<IEnumerable<long>>(x => x.GetRunIds(filter));
    20985    }
    210     #endregion
    211 
    212     #region Algorithm Methods
    213     public List<Guid> GetAlgorithmUsers(long algorithmId) {
    214       try {
    215         return CallAdministrationService<List<Guid>>(s => s.GetAlgorithmUsers(algorithmId));
    216       }
    217       catch (Exception ex) {
    218         ErrorHandling.ShowErrorDialog("Refresh authorized algorithm users failed.", ex);
    219         return null;
    220       }
    221     }
    222     public bool UpdateAlgorithmUsers(long algorithmId, List<Guid> users) {
    223       try {
    224         CallAdministrationService(s => s.UpdateAlgorithmUsers(algorithmId, users));
    225         return true;
    226       }
    227       catch (Exception ex) {
    228         ErrorHandling.ShowErrorDialog("Update authorized algorithm users failed.", ex);
    229         return false;
    230       }
    231     }
    232     public AlgorithmData GetAlgorithmData(long algorithmId) {
    233       try {
    234         return CallAdministrationService<AlgorithmData>(s => s.GetAlgorithmData(algorithmId));
    235       }
    236       catch (Exception ex) {
    237         ErrorHandling.ShowErrorDialog("Refresh algorithm data failed.", ex);
    238         return null;
    239       }
    240     }
    241     public bool UpdateAlgorithmData(AlgorithmData algorithmData) {
    242       try {
    243         CallAdministrationService(s => s.UpdateAlgorithmData(algorithmData));
    244         return true;
    245       }
    246       catch (Exception ex) {
    247         ErrorHandling.ShowErrorDialog("Update algorithm data failed.", ex);
    248         return false;
    249       }
    250     }
    251     #endregion
    252 
    253     #region Problem Methods
    254     public List<Guid> GetProblemUsers(long problemId) {
    255       try {
    256         return CallAdministrationService<List<Guid>>(s => s.GetProblemUsers(problemId));
    257       }
    258       catch (Exception ex) {
    259         ErrorHandling.ShowErrorDialog("Refresh authorized problem users failed.", ex);
    260         return null;
    261       }
    262     }
    263     public bool UpdateProblemUsers(long problemId, List<Guid> users) {
    264       try {
    265         CallAdministrationService(s => s.UpdateProblemUsers(problemId, users));
    266         return true;
    267       }
    268       catch (Exception ex) {
    269         ErrorHandling.ShowErrorDialog("Update authorized problem users failed.", ex);
    270         return false;
    271       }
    272     }
    273     public ProblemData GetProblemData(long problemId) {
    274       try {
    275         return CallAdministrationService<ProblemData>(s => s.GetProblemData(problemId));
    276       }
    277       catch (Exception ex) {
    278         ErrorHandling.ShowErrorDialog("Refresh problem data failed.", ex);
    279         return null;
    280       }
    281     }
    282     public bool UpdateProblemData(ProblemData problemData) {
    283       try {
    284         CallAdministrationService(s => s.UpdateProblemData(problemData));
    285         return true;
    286       }
    287       catch (Exception ex) {
    288         ErrorHandling.ShowErrorDialog("Update problem data failed.", ex);
    289         return false;
    290       }
    291     }
    292     #endregion
    293 
    294     #region AlgorithmParameter Methods
    295     public AlgorithmParameter GetAlgorithmParameter(long id) {
    296       try {
    297         return CallAdministrationService<AlgorithmParameter>(s => s.GetAlgorithmParameter(id));
    298       }
    299       catch (Exception ex) {
    300         ErrorHandling.ShowErrorDialog("Refresh algorithm parameter failed.", ex);
    301         return null;
    302       }
    303     }
    304     public ItemCollection<AlgorithmParameter> GetAlgorithmParameters(long algorithmId) {
    305       try {
    306         ItemCollection<AlgorithmParameter> parameters = new ItemCollection<AlgorithmParameter>();
    307         parameters.AddRange(CallAdministrationService<List<AlgorithmParameter>>(s => s.GetAlgorithmParameters(algorithmId)).OrderBy(x => x.Name));
    308         return parameters;
    309       }
    310       catch (Exception ex) {
    311         ErrorHandling.ShowErrorDialog("Refresh algorithm parameters failed.", ex);
    312         return null;
    313       }
    314     }
    315     #endregion
    316 
    317     #region ProblemParameter Methods
    318     public ProblemParameter GetProblemParameter(long id) {
    319       try {
    320         return CallAdministrationService<ProblemParameter>(s => s.GetProblemParameter(id));
    321       }
    322       catch (Exception ex) {
    323         ErrorHandling.ShowErrorDialog("Refresh problem parameter failed.", ex);
    324         return null;
    325       }
    326     }
    327     public ItemCollection<ProblemParameter> GetProblemParameters(long problemId) {
    328       try {
    329         ItemCollection<ProblemParameter> parameters = new ItemCollection<ProblemParameter>();
    330         parameters.AddRange(CallAdministrationService<List<ProblemParameter>>(s => s.GetProblemParameters(problemId)).OrderBy(x => x.Name));
    331         return parameters;
    332       }
    333       catch (Exception ex) {
    334         ErrorHandling.ShowErrorDialog("Refresh problem parameters failed.", ex);
    335         return null;
    336       }
    337     }
    338     #endregion
    339 
    340     #region Result Methods
    341     public Result GetResult(long id) {
    342       try {
    343         return CallAdministrationService<Result>(s => s.GetResult(id));
    344       }
    345       catch (Exception ex) {
    346         ErrorHandling.ShowErrorDialog("Refresh result failed.", ex);
    347         return null;
    348       }
    349     }
    350     public ItemCollection<Result> GetResults(long algorithmId) {
    351       try {
    352         ItemCollection<Result> results = new ItemCollection<Result>();
    353         results.AddRange(CallAdministrationService<List<Result>>(s => s.GetResults(algorithmId)).OrderBy(x => x.Name));
    354         return results;
    355       }
    356       catch (Exception ex) {
    357         ErrorHandling.ShowErrorDialog("Refresh results failed.", ex);
    358         return null;
    359       }
    360     }
    361     #endregion
    362 
    363     #region Experiment Methods
    364     public Experiment GetExperiment(long id) {
    365       try {
    366         return CallAdministrationService<Experiment>(s => s.GetExperiment(id));
    367       }
    368       catch (Exception ex) {
    369         ErrorHandling.ShowErrorDialog("Refresh experiment failed.", ex);
    370         return null;
    371       }
    372     }
    373     public ItemCollection<Experiment> GetExperiments(long algorithmId, long problemId) {
    374       try {
    375         ItemCollection<Experiment> experiments = new ItemCollection<Experiment>();
    376         experiments.AddRange(CallAdministrationService<List<Experiment>>(s => s.GetExperiments(algorithmId, problemId)));
    377         experiments.ItemsRemoved += new CollectionItemsChangedEventHandler<Experiment>(experiments_ItemsRemoved);
    378         return experiments;
    379       }
    380       catch (Exception ex) {
    381         ErrorHandling.ShowErrorDialog("Refresh experiments failed.", ex);
    382         return null;
    383       }
    384     }
    385     #endregion
    386 
    387     #region Run Methods
    388     public ItemCollection<Run> GetRuns(long experimentId) {
    389       try {
    390         ItemCollection<Run> runs = new ItemCollection<Run>();
    391         runs.AddRange(CallAdministrationService<List<Run>>(s => s.GetRuns(experimentId)).OrderByDescending(x => x.CreatedDate));
    392         runs.ItemsRemoved += new CollectionItemsChangedEventHandler<Run>(runs_ItemsRemoved);
    393         return runs;
    394       }
    395       catch (Exception ex) {
    396         ErrorHandling.ShowErrorDialog("Refresh runs failed.", ex);
    397         return null;
    398       }
    399     }
    400     public bool AddRun(long algorithmId, long problemId, IAlgorithm algorithm) {
    401       try {
    402         IProblem problem = algorithm.Problem;
    403 
    404         ItemCollection<AlgorithmParameter> algorithmParameters = GetAlgorithmParameters(algorithmId);
    405         List<AlgorithmParameterValue> algorithmParameterValues = CollectAlgorithmParameterValues(algorithmId, algorithmParameters, algorithm, "");
    406         ItemCollection<ProblemParameter> problemParameters = GetProblemParameters(problemId);
    407         List<ProblemParameterValue> problemParameterValues = CollectProblemParamterValues(problemId, problemParameters, problem, "");
    408         ItemCollection<Result> results = GetResults(algorithmId);
    409         List<ResultValue> resultValues = CollectResultValues(algorithmId, results, algorithm);
    410 
    411         Experiment exp = new Experiment();
    412         exp.AlgorithmId = algorithmId;
    413         exp.ProblemId = problemId;
    414         exp.AlgorithmParameterValues = algorithmParameterValues;
    415         exp.ProblemParameterValues = problemParameterValues;
    416         exp.Store();
    417 
    418         Run r = new Run();
    419         r.ExperimentId = exp.Id;
    420         r.ClientId = Guid.NewGuid();
    421         r.CreatedDate = DateTime.Now;
    422         r.RandomSeed = ((IntValue)((IValueParameter)algorithm.Parameters["Seed"]).Value).Value;
    423         r.ResultValues = resultValues;
    424         r.Store();
    425 
    426         return true;
    427       }
    428       catch (Exception ex) {
    429         ErrorHandling.ShowErrorDialog("Store run failed.", ex);
    430         return false;
    431       }
    432     }
    433 
    434     private List<AlgorithmParameterValue> CollectAlgorithmParameterValues(long algorithmId, ItemCollection<AlgorithmParameter> parameters, IParameterizedItem item, string prefix) {
    435       List<AlgorithmParameterValue> values = new List<AlgorithmParameterValue>();
    436       foreach (IValueParameter param in item.Parameters.OfType<IValueParameter>()) {
    437         if (param.GetsCollected && (param.Value != null) && (param.Name != "Seed")) {
    438           AlgorithmParameter p = parameters.FirstOrDefault(x => x.Name == prefix + param.Name);
    439           if (p == null) {
    440             p = new AlgorithmParameter();
    441             p.Name = prefix + param.Name;
    442             p.Alias = prefix + param.Name;
    443             p.Description = param.Description;
    444             p.AlgorithmId = algorithmId;
    445             p.DataTypeId = ConvertToDataType(param.DataType).Id;
    446             p.Store();
    447             parameters.Add(p);
    448           }
    449           AlgorithmParameterValue value = CreateAlgorithmParameterValue(param.Value);
    450           value.AlgorithmParameterId = p.Id;
    451           value.DataTypeId = ConvertToDataType(param.Value.GetType()).Id;
    452           values.Add(value);
    453         }
    454 
    455         if (param.Value is IParameterizedItem)
    456           values.AddRange(CollectAlgorithmParameterValues(algorithmId, parameters, (IParameterizedItem)param.Value, (string.IsNullOrEmpty(prefix) ? param.Name : prefix + param.Name) + "."));
    457       }
    458       return values;
    459     }
    460     private AlgorithmParameterValue CreateAlgorithmParameterValue(IItem item) {
    461       if (item is BoolValue) {
    462         AlgorithmParameterBoolValue value = new AlgorithmParameterBoolValue();
    463         value.Value = ((BoolValue)item).Value;
    464         return value;
    465       } else if (item is DoubleValue) {
    466         AlgorithmParameterFloatValue value = new AlgorithmParameterFloatValue();
    467         value.Value = ((DoubleValue)item).Value;
    468         return value;
    469       } else if (item is IntValue) {
    470         AlgorithmParameterIntValue value = new AlgorithmParameterIntValue();
    471         value.Value = ((IntValue)item).Value;
    472         return value;
    473       } else if (item is StringValue) {
    474         AlgorithmParameterStringValue value = new AlgorithmParameterStringValue();
    475         value.Value = ((StringValue)item).Value;
    476         return value;
    477       } else {
    478         AlgorithmParameterBlobValue value = new AlgorithmParameterBlobValue();
    479         try {
    480           using (MemoryStream stream = new MemoryStream()) {
    481             XmlGenerator.Serialize(item, stream);
    482             stream.Close();
    483             value.Value = stream.ToArray();
    484           }
    485         }
    486         catch (Exception ex) {
    487           ErrorHandling.ShowErrorDialog(ex);
    488         }
    489         return value;
    490       }
    491     }
    492     private List<ProblemParameterValue> CollectProblemParamterValues(long problemId, ItemCollection<ProblemParameter> parameters, IParameterizedItem item, string prefix) {
    493       List<ProblemParameterValue> values = new List<ProblemParameterValue>();
    494       foreach (IValueParameter param in item.Parameters.OfType<IValueParameter>()) {
    495         if (param.GetsCollected && (param.Value != null)) {
    496           ProblemParameter p = parameters.FirstOrDefault(x => x.Name == prefix + param.Name);
    497           if (p == null) {
    498             p = new ProblemParameter();
    499             p.Name = prefix + param.Name;
    500             p.Alias = prefix + param.Name;
    501             p.Description = param.Description;
    502             p.ProblemId = problemId;
    503             p.DataTypeId = ConvertToDataType(param.DataType).Id;
    504             p.Store();
    505             parameters.Add(p);
    506           }
    507           ProblemParameterValue value = CreateProblemParameterValue(param.Value);
    508           value.ProblemParameterId = p.Id;
    509           value.DataTypeId = ConvertToDataType(param.Value.GetType()).Id;
    510           values.Add(value);
    511         }
    512 
    513         if (param.Value is IParameterizedItem)
    514           values.AddRange(CollectProblemParamterValues(problemId, parameters, (IParameterizedItem)param.Value, (string.IsNullOrEmpty(prefix) ? param.Name : prefix + param.Name) + "."));
    515       }
    516       return values;
    517     }
    518     private ProblemParameterValue CreateProblemParameterValue(IItem item) {
    519       if (item is BoolValue) {
    520         ProblemParameterBoolValue value = new ProblemParameterBoolValue();
    521         value.Value = ((BoolValue)item).Value;
    522         return value;
    523       } else if (item is DoubleValue) {
    524         ProblemParameterFloatValue value = new ProblemParameterFloatValue();
    525         value.Value = ((DoubleValue)item).Value;
    526         return value;
    527       } else if (item is IntValue) {
    528         ProblemParameterIntValue value = new ProblemParameterIntValue();
    529         value.Value = ((IntValue)item).Value;
    530         return value;
    531       } else if (item is StringValue) {
    532         ProblemParameterStringValue value = new ProblemParameterStringValue();
    533         value.Value = ((StringValue)item).Value;
    534         return value;
    535       } else {
    536         ProblemParameterBlobValue value = new ProblemParameterBlobValue();
    537         try {
    538           using (MemoryStream stream = new MemoryStream()) {
    539             XmlGenerator.Serialize(item, stream);
    540             stream.Close();
    541             value.Value = stream.ToArray();
    542           }
    543         }
    544         catch (Exception ex) {
    545           ErrorHandling.ShowErrorDialog(ex);
    546         }
    547         return value;
    548       }
    549     }
    550     private List<ResultValue> CollectResultValues(long algorithmId, ItemCollection<Result> results, IAlgorithm algorithm) {
    551       List<ResultValue> values = new List<ResultValue>();
    552       foreach (IResult result in algorithm.Results) {
    553         if (result.Value != null) {
    554           Result r = results.FirstOrDefault(x => x.Name == result.Name);
    555           if (r == null) {
    556             r = new Result();
    557             r.Name = result.Name;
    558             r.Alias = result.Name;
    559             r.Description = result.Description;
    560             r.AlgorithmId = algorithmId;
    561             r.DataTypeId = ConvertToDataType(result.DataType).Id;
    562             r.Store();
    563             results.Add(r);
    564           }
    565           ResultValue value = CreateResultValue(result.Value);
    566           value.ResultId = r.Id;
    567           value.DataTypeId = ConvertToDataType(result.Value.GetType()).Id;
    568           values.Add(value);
    569         }
    570       }
    571       return values;
    572     }
    573     private ResultValue CreateResultValue(IItem item) {
    574       if (item is BoolValue) {
    575         ResultBoolValue value = new ResultBoolValue();
    576         value.Value = ((BoolValue)item).Value;
    577         return value;
    578       } else if (item is DoubleValue) {
    579         ResultFloatValue value = new ResultFloatValue();
    580         value.Value = ((DoubleValue)item).Value;
    581         return value;
    582       } else if (item is IntValue) {
    583         ResultIntValue value = new ResultIntValue();
    584         value.Value = ((IntValue)item).Value;
    585         return value;
    586       } else if (item is StringValue) {
    587         ResultStringValue value = new ResultStringValue();
    588         value.Value = ((StringValue)item).Value;
    589         return value;
    590       } else {
    591         ResultBlobValue value = new ResultBlobValue();
    592         try {
    593           using (MemoryStream stream = new MemoryStream()) {
    594             XmlGenerator.Serialize(item, stream);
    595             stream.Close();
    596             value.Value = stream.ToArray();
    597           }
    598         }
    599         catch (Exception ex) {
    600           ErrorHandling.ShowErrorDialog(ex);
    601         }
    602         return value;
    603       }
    604     }
    605     #endregion
    606 
    607     #region Query Methods
    608     private IEnumerable<Filter> filters;
    609     public IEnumerable<Filter> GetFilters(bool refresh) {
    610       if (refresh || (filters == null)) {
    611         try {
    612           filters = CallQueryService<List<Filter>>(s => s.GetFilters());
    613         }
    614         catch (Exception ex) {
    615           ErrorHandling.ShowErrorDialog("Get filters failed.", ex);
    616           return Enumerable.Empty<Filter>();
    617         }
    618       }
    619       return filters;
    620     }
    621     public IEnumerable<Filter> GetFilters() {
    622       return GetFilters(false);
    623     }
    624     public long GetNumberOfQueryResults(Filter filter) {
    625       try {
    626         return CallQueryService<long>(x => x.GetNumberOfQueryResults(filter));
    627       }
    628       catch (Exception ex) {
    629         ErrorHandling.ShowErrorDialog("Get number of query results failed.", ex);
    630         return -1;
    631       }
    632     }
    633     public IEnumerable<long> GetQueryResultIds(Filter filter) {
    634       try {
    635         return CallQueryService<IEnumerable<long>>(x => x.GetQueryResultIds(filter));
    636       }
    637       catch (Exception ex) {
    638         ErrorHandling.ShowErrorDialog("Get query result ids failed.", ex);
    639         return Enumerable.Empty<long>();
    640       }
    641     }
    642     public IEnumerable<QueryResult> GetQueryResults(IEnumerable<long> ids) {
    643       try {
    644         return CallQueryService<IEnumerable<QueryResult>>(s => s.GetQueryResults(ids.ToList()));
    645       }
    646       catch (Exception ex) {
    647         ErrorHandling.ShowErrorDialog("Get query results failed.", ex);
    648         return null;
    649       }
     86    public IEnumerable<Run> GetRuns(IEnumerable<long> ids, bool includeBinaryValues) {
     87      return CallQueryService<IEnumerable<Run>>(s => s.GetRuns(ids.ToList(), includeBinaryValues));
    65088    }
    65189    #endregion
     
    662100      if (handler != null) handler(this, EventArgs.Empty);
    663101    }
    664 
    665     private void platforms_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Platform> e) {
    666       try {
    667         foreach (Platform p in e.Items)
    668           CallAdministrationService(s => s.DeletePlatform(p.Id));
    669       }
    670       catch (Exception ex) {
    671         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    672       }
    673     }
    674     private void dataTypes_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<DataType> e) {
    675       try {
    676         foreach (DataType d in e.Items)
    677           CallAdministrationService(s => s.DeleteDataType(d.Id));
    678       }
    679       catch (Exception ex) {
    680         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    681       }
    682     }
    683     private void algorithmClasses_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<AlgorithmClass> e) {
    684       try {
    685         foreach (AlgorithmClass a in e.Items)
    686           CallAdministrationService(s => s.DeleteAlgorithmClass(a.Id));
    687       }
    688       catch (Exception ex) {
    689         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    690       }
    691     }
    692     private void algorithms_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Algorithm> e) {
    693       try {
    694         foreach (Algorithm a in e.Items)
    695           CallAdministrationService(s => s.DeleteAlgorithm(a.Id));
    696       }
    697       catch (Exception ex) {
    698         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    699       }
    700     }
    701     private void problemClasses_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<ProblemClass> e) {
    702       try {
    703         foreach (ProblemClass p in e.Items)
    704           CallAdministrationService(s => s.DeleteProblemClass(p.Id));
    705       }
    706       catch (Exception ex) {
    707         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    708       }
    709     }
    710     private void problems_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Problem> e) {
    711       try {
    712         foreach (Problem p in e.Items)
    713           CallAdministrationService(s => s.DeleteProblem(p.Id));
    714       }
    715       catch (Exception ex) {
    716         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    717       }
    718     }
    719     private void experiments_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Experiment> e) {
    720       try {
    721         foreach (Experiment exp in e.Items)
    722           CallAdministrationService(s => s.DeleteExperiment(exp.Id));
    723       }
    724       catch (Exception ex) {
    725         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    726       }
    727     }
    728     private void runs_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Run> e) {
    729       try {
    730         foreach (Run r in e.Items)
    731           CallAdministrationService(s => s.DeleteRun(r.Id));
    732       }
    733       catch (Exception ex) {
    734         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    735       }
    736     }
    737102    #endregion
    738103
    739104    #region Helpers
    740     private void CallAdministrationService(Action<IAdministrationService> call) {
    741       AdministrationServiceClient client = ClientFactory.CreateClient<AdministrationServiceClient, IAdministrationService>();
    742       try {
    743         call(client);
    744       }
    745       finally {
    746         try {
    747           client.Close();
    748         }
    749         catch (Exception) {
    750           client.Abort();
    751         }
    752       }
    753     }
    754     private T CallAdministrationService<T>(Func<IAdministrationService, T> call) {
    755       AdministrationServiceClient client = ClientFactory.CreateClient<AdministrationServiceClient, IAdministrationService>();
    756       try {
    757         return call(client);
    758       }
    759       finally {
    760         try {
    761           client.Close();
    762         }
    763         catch (Exception) {
    764           client.Abort();
    765         }
    766       }
    767     }
    768     private void CallQueryService(Action<IQueryService> call) {
    769       QueryServiceClient client = ClientFactory.CreateClient<QueryServiceClient, IQueryService>();
    770       try {
    771         call(client);
    772       }
    773       finally {
    774         try {
    775           client.Close();
    776         }
    777         catch (Exception) {
    778           client.Abort();
    779         }
    780       }
    781     }
    782105    private T CallQueryService<T>(Func<IQueryService, T> call) {
    783106      QueryServiceClient client = ClientFactory.CreateClient<QueryServiceClient, IQueryService>();
    784       try {
    785         return call(client);
    786       }
    787       finally {
    788         try {
    789           client.Close();
    790         }
    791         catch (Exception) {
    792           client.Abort();
    793         }
    794       }
    795     }
    796     private T CallAuthenticationService<T>(Func<IAuthenticationService, T> call) {
    797       AuthenticationServiceClient client = ClientFactory.CreateClient<AuthenticationServiceClient, IAuthenticationService>();
    798107      try {
    799108        return call(client);
  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query/QueryMenuItem.cs

    r5606 r5611  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.MainForm;
    2324using HeuristicLab.Optimizer;
    2425
     
    3637
    3738    public override void Execute() {
    38       QueryView view = new QueryView();
    39       view.Show();
     39      MainFormManager.MainForm.ShowContent(QueryClient.Instance);
    4040    }
    4141  }
  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query/Views/CombinedFilterView.cs

    r5606 r5611  
    2121
    2222using System;
    23 using System.Collections.Generic;
     23using System.Linq;
    2424using System.Windows.Forms;
    2525using HeuristicLab.MainForm;
     
    4141    protected override void OnInitialized(System.EventArgs e) {
    4242      base.OnInitialized(e);
    43       IEnumerable<Filter> availableFilters = QueryClient.Instance.GetFilters();
    44       filtersComboBox.DataSource = availableFilters;
     43      filtersComboBox.DataSource = QueryClient.Instance.Filters.ToList();
    4544      filtersComboBox.DisplayMember = "Label";
    4645    }
  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query/Views/QueryView.cs

    r5606 r5611  
    2222using System;
    2323using System.IO;
     24using System.Linq;
    2425using System.Threading;
    2526using System.Threading.Tasks;
     
    3334namespace HeuristicLab.Clients.OKB.Query {
    3435  [View("OKB Query")]
    35   [Content(typeof(OKBClient), false)]
    36   public sealed partial class QueryView : HeuristicLab.MainForm.WindowsForms.View {
     36  [Content(typeof(QueryClient), true)]
     37  public sealed partial class QueryView : AsynchronousContentView {
    3738    private CancellationTokenSource cancellationTokenSource;
    3839    private CombinedFilterView combinedFilterView;
    3940
     41    public new QueryClient Content {
     42      get { return (QueryClient)base.Content; }
     43      set { base.Content = value; }
     44    }
     45
    4046    public QueryView() {
    4147      InitializeComponent();
    4248    }
    4349
    44     protected override void OnInitialized(EventArgs e) {
    45       base.OnInitialized(e);
    46       LoadFiltersAsync();
    47     }
    48 
     50    protected override void DeregisterContentEvents() {
     51      Content.Refreshing -= new EventHandler(Content_Refreshing);
     52      Content.Refreshed -= new EventHandler(Content_Refreshed);
     53      base.DeregisterContentEvents();
     54    }
     55
     56    protected override void RegisterContentEvents() {
     57      base.RegisterContentEvents();
     58      Content.Refreshing += new EventHandler(Content_Refreshing);
     59      Content.Refreshed += new EventHandler(Content_Refreshed);
     60    }
     61
     62    protected override void OnContentChanged() {
     63      base.OnContentChanged();
     64      CreateFilterView();
     65      runCollectionView.Content = null;
     66    }
    4967
    5068    protected override void SetEnabledStateOfControls() {
     
    5371    }
    5472
    55     #region Load Filters
    56     private void LoadFiltersAsync() {
    57       Cursor = Cursors.AppStarting;
    58       filtersInfoPanel.Visible = true;
    59       splitContainer.Enabled = false;
    60 
    61       Task<CombinedFilter> task = Task.Factory.StartNew<CombinedFilter>(() => {
    62         return OKBClient.Instance.GetFilters().OfType<CombinedFilter>().Where(x => x.Operation == BooleanOperation.And).FirstOrDefault();
    63       });
    64       task.ContinueWith(t => {
    65         CombinedFilter filter = t.Result;
    66         Invoke(new Action(() => {
    67           if (filter != null) {
    68             combinedFilterView = (CombinedFilterView)MainFormManager.CreateView(typeof(CombinedFilterView));
    69             combinedFilterView.Content = (CombinedFilter)filter.Clone();
    70             Control control = (Control)combinedFilterView;
    71             control.Dock = DockStyle.Fill;
    72             filterPanel.Controls.Add(control);
    73           }
    74           filtersInfoPanel.Visible = false;
    75           splitContainer.Enabled = true;
    76           this.Cursor = Cursors.Default;
    77           SetEnabledStateOfControls();
    78         }));
    79       });
    80     }
    81     #endregion
     73    private void Content_Refreshing(object sender, EventArgs e) {
     74      if (InvokeRequired) {
     75        Invoke(new EventHandler(Content_Refreshing), sender, e);
     76      } else {
     77        Cursor = Cursors.AppStarting;
     78        filtersInfoPanel.Visible = true;
     79        splitContainer.Enabled = false;
     80      }
     81    }
     82    private void Content_Refreshed(object sender, EventArgs e) {
     83      if (InvokeRequired) {
     84        Invoke(new EventHandler(Content_Refreshed), sender, e);
     85      } else {
     86        CreateFilterView();
     87        filtersInfoPanel.Visible = false;
     88        splitContainer.Enabled = true;
     89        Cursor = Cursors.Default;
     90        SetEnabledStateOfControls();
     91      }
     92    }
    8293
    8394    #region Load Results
     
    96107
    97108      Task task = Task.Factory.StartNew(() => {
    98         var ids = OKBClient.Instance.GetQueryResultIds(combinedFilterView.Content);
     109        var ids = QueryClient.Instance.GetRunIds(combinedFilterView.Content);
    99110        int idsCount = ids.Count();
    100111
     
    109120        while (ids.Count() > 0) {
    110121          cancellationToken.ThrowIfCancellationRequested();
    111           runs.AddRange(OKBClient.Instance.GetQueryResults(ids.Take(batchSize)).Select(x => ConvertToOptimizationRun(x, deserialize)));
     122          runs.AddRange(QueryClient.Instance.GetRuns(ids.Take(batchSize), true).Select(x => ConvertToOptimizationRun(x, deserialize)));
    112123          ids = ids.Skip(batchSize);
    113124          Invoke(new Action(() => {
     
    142153    }
    143154
    144     private Optimization.IRun ConvertToOptimizationRun(QueryResult queryResult, bool deserialize) {
    145       Optimization.Run run = new Optimization.Run();
    146       foreach (QueryValue value in queryResult.AlgorithmParameters)
    147         run.Parameters.Add(value.Name, ConvertToItem(value, deserialize));
    148       foreach (QueryValue value in queryResult.ProblemParameters)
    149         run.Parameters.Add(value.Name, ConvertToItem(value, deserialize));
    150       foreach (QueryValue value in queryResult.Results)
    151         run.Results.Add(value.Name, ConvertToItem(value, deserialize));
    152       return run;
    153     }
    154 
    155     private IItem ConvertToItem(QueryValue value, bool deserialize) {
    156       if (value is QueryBlobValue) {
     155    private void CreateFilterView() {
     156      combinedFilterView = null;
     157      filterPanel.Controls.Clear();
     158      if ((Content != null) && (Content.Filters != null)) {
     159        CombinedFilter filter = Content.Filters.OfType<CombinedFilter>().Where(x => x.Operation == BooleanOperation.And).FirstOrDefault();
     160        if (filter != null) {
     161          combinedFilterView = (CombinedFilterView)MainFormManager.CreateView(typeof(CombinedFilterView));
     162          combinedFilterView.Content = (CombinedFilter)filter.Clone();
     163          Control control = (Control)combinedFilterView;
     164          control.Dock = DockStyle.Fill;
     165          filterPanel.Controls.Add(control);
     166        }
     167      }
     168    }
     169
     170    private Optimization.IRun ConvertToOptimizationRun(Run run, bool deserialize) {
     171      Optimization.Run optRun = new Optimization.Run();
     172      foreach (Value value in run.ParameterValues)
     173        optRun.Parameters.Add(value.Name, ConvertToItem(value, deserialize));
     174      foreach (Value value in run.ResultValues)
     175        optRun.Results.Add(value.Name, ConvertToItem(value, deserialize));
     176      return optRun;
     177    }
     178
     179    private IItem ConvertToItem(Value value, bool deserialize) {
     180      if (value is BinaryValue) {
    157181        if (deserialize) {
    158182          IItem item = null;
    159           using (MemoryStream stream = new MemoryStream(((QueryBlobValue)value).Value)) {
     183          using (MemoryStream stream = new MemoryStream(((BinaryValue)value).Value)) {
    160184            try {
    161185              item = XmlParser.Deserialize<IItem>(stream);
     
    164188            stream.Close();
    165189          }
    166           return item != null ? item : new StringValue(((QueryBlobValue)value).DataTypeName);
     190          return item != null ? item : new Data.StringValue(value.DataType.Name);
    167191        } else {
    168           return new StringValue(((QueryBlobValue)value).DataTypeName);
     192          return new Data.StringValue(value.DataType.Name);
    169193        }
    170       } else if (value is QueryBoolValue) {
    171         return new BoolValue(((QueryBoolValue)value).Value);
    172       } else if (value is QueryFloatValue) {
    173         return new DoubleValue(((QueryFloatValue)value).Value);
    174       } else if (value is QueryIntValue) {
    175         return new IntValue((int)((QueryIntValue)value).Value);
    176       } else if (value is QueryStringValue) {
    177         return new StringValue(((QueryStringValue)value).Value);
     194      } else if (value is BoolValue) {
     195        return new Data.BoolValue(((BoolValue)value).Value);
     196      } else if (value is FloatValue) {
     197        return new Data.DoubleValue(((FloatValue)value).Value);
     198      } else if (value is DoubleValue) {
     199        return new Data.DoubleValue(((FloatValue)value).Value);
     200      } else if (value is IntValue) {
     201        return new Data.IntValue((int)((IntValue)value).Value);
     202      } else if (value is LongValue) {
     203        return new Data.IntValue((int)((IntValue)value).Value);
     204      } else if (value is StringValue) {
     205        return new Data.StringValue(((StringValue)value).Value);
    178206      }
    179207      return null;
  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query/Views/StringComparisonAvailableValuesFilterView.Designer.cs

    r5606 r5611  
    4545    /// </summary>
    4646    private void InitializeComponent() {
     47      this.comparisonComboBox = new System.Windows.Forms.ComboBox();
    4748      this.valueComboBox = new System.Windows.Forms.ComboBox();
    4849      ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
     
    6263      //
    6364      //
     65      // splitContainer2.Panel1
     66      //
     67      this.splitContainer2.Panel1.Controls.Add(this.comparisonComboBox);
     68      //
    6469      // splitContainer2.Panel2
    6570      //
    6671      this.splitContainer2.Panel2.Controls.Add(this.valueComboBox);
     72      //
     73      // comparisonComboBox
     74      //
     75      this.comparisonComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
     76      this.comparisonComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
     77      this.comparisonComboBox.FormattingEnabled = true;
     78      this.comparisonComboBox.Items.AddRange(new object[] {
     79            "=",
     80            "<>",
     81            "contains",
     82            "not contains",
     83            "like",
     84            "not like"});
     85      this.comparisonComboBox.Location = new System.Drawing.Point(3, 2);
     86      this.comparisonComboBox.Name = "comparisonComboBox";
     87      this.comparisonComboBox.Size = new System.Drawing.Size(100, 21);
     88      this.comparisonComboBox.TabIndex = 0;
     89      this.comparisonComboBox.SelectedIndexChanged += new System.EventHandler(this.comparisonComboBox_SelectedIndexChanged);
    6790      //
    6891      // valueComboBox
     
    96119    #endregion
    97120
     121    private System.Windows.Forms.ComboBox comparisonComboBox;
    98122    private System.Windows.Forms.ComboBox valueComboBox;
    99 
    100 
    101 
    102 
    103 
    104123
    105124  }
  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query/Views/StringComparisonAvailableValuesFilterView.cs

    r5606 r5611  
    2727  [View("StringComparisonAvailableValuesFilter View")]
    2828  [Content(typeof(StringComparisonAvailableValuesFilter), true)]
    29   public partial class StringComparisonAvailableValuesFilterView : StringComparisonFilterView {
     29  public partial class StringComparisonAvailableValuesFilterView : FilterView {
    3030    public new StringComparisonAvailableValuesFilter Content {
    3131      get { return (StringComparisonAvailableValuesFilter)base.Content; }
     
    3939    protected override void OnContentChanged() {
    4040      base.OnContentChanged();
     41      comparisonComboBox.SelectedIndex = -1;
     42      if (Content != null) {
     43        if (Content.Comparison == StringComparison.Equal)
     44          comparisonComboBox.SelectedItem = "=";
     45        else if (Content.Comparison == StringComparison.NotEqual)
     46          comparisonComboBox.SelectedItem = "<>";
     47        else if (Content.Comparison == StringComparison.Contains)
     48          comparisonComboBox.SelectedItem = "contains";
     49        else if (Content.Comparison == StringComparison.NotContains)
     50          comparisonComboBox.SelectedItem = "not contains";
     51        else if (Content.Comparison == StringComparison.Like)
     52          comparisonComboBox.SelectedItem = "like";
     53        else if (Content.Comparison == StringComparison.NotLike)
     54          comparisonComboBox.SelectedItem = "not like";
     55      }
    4156      valueComboBox.DataSource = Content == null ? null : Content.AvailableValues;
    4257      valueComboBox.Text = Content == null ? string.Empty : Content.Value;
     
    4560    protected override void SetEnabledStateOfControls() {
    4661      base.SetEnabledStateOfControls();
     62      comparisonComboBox.Enabled = Content != null && !ReadOnly;
    4763      valueComboBox.Enabled = Content != null && !ReadOnly;
     64    }
     65
     66    private void comparisonComboBox_SelectedIndexChanged(object sender, System.EventArgs e) {
     67      if (Content != null) {
     68        if (comparisonComboBox.SelectedItem == "=")
     69          Content.Comparison = StringComparison.Equal;
     70        else if (comparisonComboBox.SelectedItem == "<>")
     71          Content.Comparison = StringComparison.NotEqual;
     72        else if (comparisonComboBox.SelectedItem == "contains")
     73          Content.Comparison = StringComparison.Contains;
     74        else if (comparisonComboBox.SelectedItem == "not contains")
     75          Content.Comparison = StringComparison.NotContains;
     76        else if (comparisonComboBox.SelectedItem == "like")
     77          Content.Comparison = StringComparison.Like;
     78        else if (comparisonComboBox.SelectedItem == "not like")
     79          Content.Comparison = StringComparison.NotLike;
     80      }
    4881    }
    4982
     
    6093        Content.Value = valueComboBox.Text;
    6194      }
    62 
    6395    }
    6496  }
  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Query/Views/StringComparisonFilterView.Designer.cs

    r5608 r5611  
    120120    private System.Windows.Forms.TextBox valueTextBox;
    121121
    122 
    123 
    124122  }
    125123}
Note: See TracChangeset for help on using the changeset viewer.