{$INCLUDE MITEC_DEF.INC}

unit Viewer;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  Dialogs, Menus, ExtCtrls, ComCtrls, ImgList, MSI_GUI, Buttons, StdCtrls,
  MSI_CPUUsage, MSI_Common, MSI_Memory;

type
  TCategory = (msicMachine, msicCPU, msicCPUCache, msicCPUFS, msicCPUFSStd1,
               msicCPUFSStd2,msicCPUFSExt1,msicCPUFSExt2,msicCPUFSAPM, msicMemory,
               msicMotherboard, msicBus, msicVideo,msicMonitor, msicAudio,
               msicNetwork,msicPrinter, msicDevice,  msicSMBIOS, msicUSB,
               msicWinStorage, msicPhysDrive, msicLogDrive, msicNetDrive, msicRemovableDrive, msicOtherDrive,
               msicASPI, msicSMBIOSMemoryModule, msicSMBIOSMemoryDevice, msicSMBIOSProcessor,
               msicSMBIOSMemCtrl,msicSMBIOSSystemSlot, msicSMBIOSCache,
               msicSMBIOSPort, msicSMBIOSChassis,msicSMBIOSBIOS, msicSMBIOSSystem,
               msicSMBIOSMainboard, msicSMBIOSOnBoardDevice, msicSMBIOSTemperatureProbe,
               msicOther);

  Tmdi_msi_Viewer = class(TForm)
    sb: TStatusBar;
    List: TListView;
    Splitter1: TSplitter;
    MainMenu: TMainMenu;
    TreeImages: TImageList;
    View1: TMenuItem;
    mmOverview: TMenuItem;
    N3: TMenuItem;
    mmFullExpand: TMenuItem;
    mmFullCollapse: TMenuItem;
    MSIC: TMiTeC_SystemInfo;
    Tree: TTreeView;
    DataPanel: TPanel;
    OverviewIcon: TImage;
    lMachine: TLabel;
    lOS: TLabel;
    Bevel2: TBevel;
    lVersion: TLabel;
    lDate: TLabel;
    N1: TMenuItem;
    mmTO: TMenuItem;
    procedure mmTOClick(Sender: TObject);
    procedure OverviewIconDblClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure mmOverviewClick(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure TreeDeletion(Sender: TObject; Node: TTreeNode);
    procedure TreeChange(Sender: TObject; Node: TTreeNode);
    procedure cmExit(Sender: TObject);
    procedure ListAdvancedCustomDrawItem(Sender: TCustomListView;
      Item: TListItem; State: TCustomDrawState; Stage: TCustomDrawStage;
      var DefaultDraw: Boolean);
    procedure ListAdvancedCustomDrawSubItem(Sender: TCustomListView;
      Item: TListItem; SubItem: Integer; State: TCustomDrawState;
      Stage: TCustomDrawStage; var DefaultDraw: Boolean);
    procedure TreeGetImageIndex(Sender: TObject; Node: TTreeNode);
    procedure mmFullExpandClick(Sender: TObject);
    procedure mmFullCollapseClick(Sender: TObject);
    procedure ListDblClick(Sender: TObject);
  private
    function GetTreePath(ANode: TTreeNode): string;
    procedure CreateTree;
    procedure CreateCPUTree(ARoot: TTreeNode);
    procedure CreateMemoryTree(ARoot: TTreeNode);
    procedure CreateMotherboardTree(ARoot: TTreeNode);
    procedure CreateBusTree(ARoot: TTreeNode);
    procedure CreateVideoTree(ARoot: TTreeNode);
    procedure CreateMonitorTree(ARoot: TTreeNode);
    procedure CreateStorageTree(ARoot: TTreeNode);
    procedure CreateAudioTree(ARoot: TTreeNode);
    procedure CreateNetworkTree(ARoot: TTreeNode);
    procedure CreatePortsTree(ARoot: TTreeNode);
    procedure CreateUSBTree(ARoot: TTreeNode);
    procedure CreatePrintersTree(ARoot: TTreeNode);

    procedure DisplayMachineInfo;
    procedure DisplayCPUInfo;
    procedure DisplayCPUDetail(AIndex: Integer);
    procedure DisplayCPUCache(AIndex: Integer);
    procedure DisplayCPUFS(AIndex: Integer);
    procedure DisplayCPUFSStd1(AIndex: Integer);
    procedure DisplayCPUFSStd2(AIndex: Integer);
    procedure DisplayCPUFSExt1(AIndex: Integer);
    procedure DisplayCPUFSExt2(AIndex: Integer);
    procedure DisplayCPUFSAPM(AIndex: Integer);
    procedure DisplayMemoryInfo;
    procedure DisplaySMBIOSInfo;
    procedure DisplaySMBIOSSystemInfo;
    procedure DisplaySMBIOSChassisInfo;
    procedure DisplaySMBIOSMainboardInfo;
    procedure DisplaySMBIOSBIOSInfo;
    procedure DisplaySMBIOSMemCtrlInfo;
    procedure DisplaySMBIOSMemoryModuleDetail(AIndex: Integer);
    procedure DisplaySMBIOSMemoryDeviceDetail(AIndex: Integer);
    procedure DisplaySMBIOSProcessorDetail(AIndex: Integer);
    procedure DisplaySMBIOSCacheDetail(AIndex: Integer);
    procedure DisplaySMBIOSSystemSlotDetail(AIndex: Integer);
    procedure DisplaySMBIOSPortDetail(AIndex: Integer);
    procedure DisplaySMBIOSOnBoardDeviceDetail(AIndex: Integer);
    procedure DisplaySMBIOSTempProbeDetail(AIndex: Integer);
    procedure DisplayMotherboardInfo;
    procedure DisplayDeviceInfo;
    procedure DisplayDeviceDetail(AIndex: Integer);
    procedure DisplayVideoDetail;
    procedure DisplayMonitorDetail(AIndex: Integer);
    procedure DisplayPhysDriveDetail(AIndex: Integer);
    procedure DisplayLogDriveDetail(AIndex: Integer);
    procedure DisplayOtherDriveDetail(AIndex: Integer);
    procedure DisplayWinStorageDetail(AIndex: Integer);
    procedure DisplayASPIDetail(AIndex: Integer);
    procedure DisplayAudioDetail;
    procedure DisplayNetworkInfo;
    procedure DisplayNetworkDetail(AIndex: Integer);
    procedure DisplayUSBDetail(AIndex: Integer);
    procedure DisplayUSBSummary;
    procedure DisplayPrinterDetail(AIndex: Integer);
    procedure DisplayNodeInfo;
  public
    procedure RefreshData;

    procedure OpenFile(AFilename: string);
    procedure OpenLocal;
    procedure SetControls;
  end;

var
  mdi_msi_Viewer: Tmdi_msi_Viewer;

resourcestring
  {$I MSI_Resources.inc}

implementation

uses Main, MSI_CPU, MSI_SMBIOS, MSI_Devices, MSI_USB, MiTeC_USB, MiTeC_CtrlRtns,
  MiTeC_Datetime, MiTeC_Routines, MiTeC_NTDDK, MSI_Network,
  Clipbrd, MSI_Splash, MiTeC_WinIOCTL, MiTeC_StrUtils, EODlg;

{$R *.dfm}

procedure Tmdi_msi_Viewer.RefreshData;
begin
  Screen.Cursor:=crHourglass;
  ShowSplash;
  DataPanel.Visible:=not MSIC.LiveData;
  try
    if MSIC.LiveData then
      MSIC.RefreshData
    {$IFDEF SIS}
    else begin
      MSIC.LoadFromStorage(MSIC.StorageFileName);

      lMachine.Caption:=MSIC.StorageInfo.Machine;
      lOS.Caption:=Format('%s / %s',[MSIC.StorageInfo.OS,
                                              MSIC.StorageInfo.Security
                                             ]);
      lVersion.Caption:=Format('Version: %s',[MSIC.StorageInfo.Version]);
      lDate.Caption:=Format('Created: %s',[DateTimeToStr(MSIC.StorageInfo.Timestamp)]);
    end;
    {$ENDIF}
  finally
    CreateTree;
    HideSplash;
    Screen.Cursor:=crDefault;
  end;
end;

procedure Tmdi_msi_Viewer.CreateTree;
var
  Root: TTreeNode;
  pi: PInteger;
begin
  with Tree, Items do begin
    BeginUpdate;
    try
      Clear;

      new(pi);
      pi^:=256*BYTE(msicMachine);
      if MSIC.Machine.Computer='' then
        Root:=AddObject(nil,rsComputer,pi)
      else
        Root:=AddObject(nil,MSIC.Machine.Computer,pi);

      CreateCPUTree(Root);
      CreateMemoryTree(Root);
      CreateMotherboardTree(Root);
      CreateBusTree(Root);
      CreateVideoTree(Root);
      CreateMonitorTree(Root);
      CreateStorageTree(Root);
      CreateUSBTree(Root);
      CreateAudioTree(Root);
      CreateNetworkTree(Root);
      CreatePortsTree(Root);
      CreatePrintersTree(Root);
    finally
      EndUpdate;
      Root.Expand(False);
      Tree.Selected:=Tree.Items.GetFirstNode;
      Tree.OnChange(Tree,Tree.Selected);
    end;
  end;
end;

procedure Tmdi_msi_Viewer.CreateUSBTree(ARoot: TTreeNode);
var
  r,n2: TTreeNode;
  pi: PInteger;
  i: Integer;
  s: string;

function FindUSBNode(ARoot: TTreeNode; AIndex: Integer): TTreeNode;
var
  n: TTreeNode;
begin
  Result:=nil;
  n:=ARoot;
  while Assigned(n) do begin
    if Assigned(n.Data) and (Lo(PInteger(n.Data)^)-1=AIndex) then begin
      Result:=n;
      Break;
    end;
    n:=n.GetNext;
  end;
  if not Assigned(Result) then
    Result:=ARoot;
end;

begin
  if MSIC.USB.USBNodeCount>0 then
    with Tree.Items do
      with MSIC.USB do begin
        new(pi);
        pi^:=256*BYTE(msicUSB);
        n2:=AddChildObject(ARoot,rsUSB,pi);
        for i:=0 to USBNodeCount-1 do
          with USBNodes[i] do begin
            s:='';
            case USBClass of
              usbHostController: s:=s+Format('%s %d',[ClassNames[integer(USBClass)],USBDevice.Port]);
              usbHub: s:=s+ClassNames[integer(USBClass)];
              else begin
                if USBDevice.ConnectionStatus=1 then begin
                  if USBClass=usbExternalHub then
                    s:=s+Format('Port[%d]: %s',[USBDevice.Port,ClassNames[integer(USBClass)]])
                  else
                    s:=s+Format('Port[%d]: %s',[USBDevice.Port,ClassNames[integer(USBClass)]]);
                end else begin
                  s:=s+Format('Port[%d]: %s',[USBDevice.Port,ConnectionStates[USBDevice.ConnectionStatus]]);
                end;
              end;
          end;
        r:=FindUSBNode(n2,ParentIndex);
        new(pi);
        if (USBClass in [usbReserved..usbStorage,usbVendorSpec,usbUnknown,usbError]) then
          pi^:=(i+1)+256*Byte(msicUSB)
        else
          pi^:=(i+1)+256*Byte(msicOther);
        Tree.Items.AddChildObject(r,s,pi);
      end;
    end;
end;

procedure Tmdi_msi_Viewer.TreeDeletion(Sender: TObject; Node: TTreeNode);
begin
  if Assigned(Node) and Assigned(Node.Data) then
    Dispose(PInteger(Node.Data));
end;

procedure Tmdi_msi_Viewer.CreateMotherboardTree(ARoot: TTreeNode);
var
  n1,n2,n3: TTreeNode;
  pi: PInteger;
  i: Integer;
begin
  with Tree, Items do begin
    new(pi);
    pi^:=256*BYTE(msicMotherboard);
    n1:=AddChildObject(ARoot,rsMotherboard,pi);
    new(pi);
    pi^:=256*BYTE(msicDevice);
    n2:=AddChildObject(n1,Format('%s %s',[rsACPI,rsDevices]),pi);
    with MSIC.Devices do
      for i:=0 to DeviceCount-1 do   
        if (Pos('ACPI\',Devices[i].HardwareID)=1) then begin
          new(pi);
          pi^:=(i+1)+256*BYTE(msicDevice);
          AddChildObject(n2,Devices[i].Name,pi);
        end;
    new(pi);
    pi^:=256*BYTE(msicSMBIOS);
    n2:=AddChildObject(n1,rsSMBIOS,pi);
    new(pi);
    pi^:=256*BYTE(msicSMBIOSBIOS);
    AddChildObject(n2,rsBIOS,pi);
    new(pi);
    pi^:=256*BYTE(msicSMBIOSSystem);
    AddChildObject(n2,rsSystem,pi);
    new(pi);
    pi^:=256*BYTE(msicSMBIOSMainboard);
    AddChildObject(n2,rsMainboard,pi);
    new(pi);
    pi^:=256*BYTE(msicSMBIOSChassis);
    AddChildObject(n2,rsChassis,pi);
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,rsProcessor,pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to ProcessorCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*BYTE(msicSMBIOSProcessor);
        AddChildObject(n3,Format('%s',[Processor[i].Manufacturer]),pi);
      end;
    new(pi);
    pi^:=256*BYTE(msicSMBIOSMemCtrl);
    AddChildObject(n2,Format('%s %s',[rsMemory,rsController]),pi);
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,Format('%s %s',[rsMemory,rsModules]),pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to MemoryModuleCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*BYTE(msicSMBIOSMemoryModule);
        AddChildObject(n3,Format('%s',[MemoryModule[i].Socket]),pi);
      end;
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,Format('%s %s',[rsMemory,rsDevices]),pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to MemoryDeviceCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*BYTE(msicSMBIOSMemoryDevice);
        AddChildObject(n3,Format('%s',[MemoryDevice[i].DeviceLocator]),pi);
      end;
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,rsCache,pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to CacheCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*BYTE(msicSMBIOSCache);
        AddChildObject(n3,Format('%s',[Cache[i].Designation]),pi);
      end;
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,rsPortConnectors,pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to PortCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*BYTE(msicSMBIOSPort);
        AddChildObject(n3,Format('%s',[PortTypes[Port[i].Typ]]),pi);
      end;
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,Format('%s %s',[rsSystem,rsSlots]),pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to SystemSlotCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*Byte(msicSMBIOSSystemSlot);
        AddChildObject(n3,Format('%s',[SlotTypes[SystemSlot[i].Typ]]),pi);
      end;
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,Format('%s %s',[rsOnBoard,rsDevices]),pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to OnBoardDeviceCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*Byte(msicSMBIOSOnBoardDevice);
        AddChildObject(n3,Format('%s',[OnBoardDevice[i].DeviceName]),pi);
      end;
    new(pi);
    pi^:=256*BYTE(msicOther);
    n3:=AddChildObject(n2,Format('%s %s',[rsTemperature,rsProbe]),pi);
    with MSIC.Machine.SMBIOS do
      for i:=0 to TemperatureProbeCount-1 do begin
        new(pi);
        pi^:=(i+1)+256*Byte(msicSMBIOSTemperatureProbe);
        AddChildObject(n3,Format('%s',[TemperatureProbe[i].Description]),pi);
      end;
  end;
end;

procedure Tmdi_msi_Viewer.CreateCPUTree(ARoot: TTreeNode);
var
  n1,n2,n3: TTreeNode;
  pi: PInteger;
  i,c: Integer;
  s: string;
begin
  with Tree, Items do begin
    new(pi);
    pi^:=256*Byte(msicCPU);
    n1:=AddChildObject(ARoot,rsCentralProcessor,pi);
    with MSIC.CPU do begin
      c:=CPUCount;
      for i:=0 to c-1 do begin
        CPUIndex:=i;