Ciaphas fucked around with this message at 00:25 on Jul 12, 2014

public class DataRecord
{
   public ulong Yeartime { get; set; }
   public List<DataItem> Items {get; set; }
}

public class DataItem
{
   public MetaData Info {get; set;}
   public object Data {get; set;} // any of IntX, UIntX, single, double, byte[], char[]
   public string DataAsString { get { /* ... */ } }
}

public class MetaData
{
   public string Name {get; set;}
   public DataType Type {get; set;} // enum, not important
   // ...
}

Ciaphas fucked around with this message at 21:01 on Jul 16, 2014

Ciaphas fucked around with this message at 05:02 on Jul 17, 2014

class DataRecordDisplay
{
   public ulong Yeartime {get; set;}
   public string NameOfItem1 {get; set;}
   public string NameOfItem2 {get; set;}
   // etc.
}

Ciaphas fucked around with this message at 19:09 on Jul 17, 2014

Ciaphas fucked around with this message at 00:33 on Aug 27, 2014

// view code-behind
    public partial class MainWindow : Window
    {
        private MainWindowViewModel MWVM;
        public MainWindow()
        {
            MWVM = new MainWindowViewModel();
            DataContext = MWVM;

            //////////////////////////////////
            MWVM.DataUpdated = OnDataUpdated;
            //////////////////////////////////

            InitializeComponent();
        }
        
        //////////////////////////////
        private void OnDataUpdated()
        {
            MessageBox.Show("fart");
        }
        //////////////////////////////
    }

// view model
    class MainWindowViewModel : ViewModelBase // ViewModelBase implements INotifyParameterChanged and IDisposable if you give a poo poo
    {
        public Action DataUpdated { get; set; }
        
        // blah blah blah

        private void UpdateData() // pretend some RelayCommand bound in the view calls this :effort:
        {
            // blah blah blah

            ///////////////////////////////////
            if (DataUpdated != null)
                DataUpdated();
            ///////////////////////////////////
        }
    }

Ciaphas fucked around with this message at 06:17 on Aug 27, 2014

Ciaphas fucked around with this message at 00:11 on Apr 23, 2015

Ciaphas fucked around with this message at 17:54 on Apr 23, 2015

<Label Name="recordCount" Text="{Binding RawRecords.Count}"/>
<!-- or is it Content, not Text? I forget -->

Ciaphas fucked around with this message at 19:30 on Apr 23, 2015

Ciaphas fucked around with this message at 00:14 on Apr 24, 2015

public class RawRecord
{
  // ...
  public byte[] Payload {get; set;}
  public string PayloadHex { get {
    StringBuilder s = new StringBuilder();
    foreach (var b in Payload) s.AppendFormat("{0:X2} ", b); // something like that I think
    return s.ToString();
  }}
}

<!-- I might be loving up some property names, going from memory -->
<!-- Also, DataContext is my viewmodel, RawRecords is ObservableCollection<RawRecord> -->
<DataGrid ItemsContent="{Binding RawRecords}">
  <DataGridTextColumn Text="{Binding PayloadHex}" />
  <!-- ... -->
</DataGrid>

Ciaphas fucked around with this message at 22:43 on Apr 30, 2015

<!-- main window, datacontext is viewmodel -->
<Button Content="Open Sub-window" Command="{Binding OpenSubWindowCommand}"/>

interface IWindowService // everything's an object because maybe a test harness view wouldn't use System.Windows.Window???
{
  object OpenWindow(object window);
  bool FocusWindow(object window);
  bool CloseWindow(object window);
}

class WindowService : IWindowService
{
  object OpenWindow(object window)
  {
    // type checks here
    if (window as string == "SubWindow")
    {
      System.Windows.Window w = new Window();
      w.Show();
      return w;
    }
  }
  bool FocusWindow(object window) { return (window as Window).Focus(); }
  bool CloseWindow(object window) { (window as Window).Close(); return true; }
}

class MainWindowViewModel : IDisposable
{
  private IWindowService _MyWindowService; // set in ctor
  public RelayCommand OpenSubWindowCommand = new RelayCommand(x=>OpenSubWindow());

  private object _SubWindow;
  private void OpenSubWindow()
  {
    _SubWindow = _MyWindowService.OpenWindow("SubWindow");
  } 
  
  private void FocusSubWindow() // pretend I had the command etc for this too
  {
    if (_SubWindow != null) _MyWindowService.FocusWindow(_SubWindow);
  }

  public void Dispose()
  {
    if (_SubWindow != null) MyWindowService.CloseWindow(_SubWindow);
  }
}

Ciaphas fucked around with this message at 20:59 on May 7, 2015

// i probably ballsed up the syntax here somewhere
public class MySharedCommand : RelayCommand
{
    // base const. takes Action<object>, Predicate<object> to implement Execute and CanExecute from ICommand
    public MySharedCommand() : base(Execute, CanExecute) {}
    
    public void Execute(object parms) { ... }
    public bool CanExecute(object parms) { ... }
}

Ciaphas fucked around with this message at 19:17 on Jul 24, 2015

Ciaphas fucked around with this message at 22:48 on Jul 24, 2015

Ciaphas fucked around with this message at 22:48 on Jul 24, 2015

Ciaphas fucked around with this message at 22:51 on Jul 26, 2015

Ciaphas fucked around with this message at 16:18 on Jul 30, 2015

class Request : IEquatable<Request>
{
   public string FileName {get; set;} // whatever

   public override bool Equals(object rhs)
   {
      if (base.Equals(rhs)) return true;
      if (rhs.Type() != this.Type()) return false;

      return Equals(rhs as Request);
   }
   public bool Equals(Request rhs) // implements IEquatable
   {
      return FileName == rhs.FileName; // or whatever other value semantics...
   }
}

Ciaphas fucked around with this message at 16:25 on Jul 30, 2015