root/trunk/UMain.pas

unit UMain;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ComCtrls, Menus, Workspaces, Projects, ImgList;

const
     ObjHeaderText     = 'Object Files';
     ErrorHeaderText   = 'Errors'; { node.data points to this }

type
  TmainForm = class(TForm)
    treeView: TTreeView;
    wsMenu: TMainMenu;
    Workspace1: TMenuItem;
    New1: TMenuItem;
    Load1: TMenuItem;
    Save1: TMenuItem;
    Settings1: TMenuItem;
    Quit1: TMenuItem;
    FileDialog: TOpenDialog;
    Close1: TMenuItem;
    WorkspacePopup: TPopupMenu;
    PMNewProject: TMenuItem;
    ProjectPopup: TPopupMenu;
    Add1: TMenuItem;
    BuildLibMenu: TMenuItem;
    Settings2: TMenuItem;
    Close2: TMenuItem;
    SaveProject1: TMenuItem;
    PMSettings: TMenuItem;
    PMClose: TMenuItem;
    PMLoadProject: TMenuItem;
    SaveAll1: TMenuItem;
    SourcePopup: TPopupMenu;
    Compile1: TMenuItem;
    Remove1: TMenuItem;
    PMSave: TMenuItem;
    Edit1: TMenuItem;
    Refresh1: TMenuItem;
    SaveDialog: TSaveDialog;
    StatusBar: TStatusBar;
    Build1: TMenuItem;
    About1: TMenuItem;
    FullBuild1: TMenuItem;
    VersionSubmenu: TMenuItem;
    BuildRun1: TMenuItem;
    Options1: TMenuItem;
    StayonTopMenu: TMenuItem;
    IconImages: TImageList;
    procedure Quit1Click(Sender: TObject);
    procedure Settings1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure New1Click(Sender: TObject);
    procedure Load1Click(Sender: TObject);
    procedure Close1Click(Sender: TObject);
    procedure treeViewMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure PMNewProjectClick(Sender: TObject);
    procedure Settings2Click(Sender: TObject);
    procedure Save1Click(Sender: TObject);
    procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
    procedure PMSettingsClick(Sender: TObject);
    procedure PMCloseClick(Sender: TObject);
    procedure PMLoadProjectClick(Sender: TObject);
    procedure Close2Click(Sender: TObject);
    procedure Add1Click(Sender: TObject);
    procedure SaveAll1Click(Sender: TObject);
    procedure Remove1Click(Sender: TObject);
    procedure Compile1Click(Sender: TObject);
    procedure PMSaveClick(Sender: TObject);
    procedure Edit1Click(Sender: TObject);
    procedure treeViewDblClick(Sender: TObject);
    procedure SaveProject1Click(Sender: TObject);
    procedure BuildMenuClick(Sender: TObject);
    procedure BuildLibMenuClick(Sender: TObject);
    procedure Refresh1Click(Sender: TObject);
    procedure BuildSubMenuClick(Sender: TObject);
    procedure Build1Click(Sender: TObject);
    procedure About1Click(Sender: TObject);
    procedure FullBuild1Click(Sender: TObject);
    procedure BuildRun1Click(Sender: TObject);
    procedure StayonTopMenuClick(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }

    procedure ToggleMenuItem(Sender: TObject);

    procedure SelectWorkspace() ;    
    procedure EditWorkspace() ;
    procedure CreateWorkspace() ;
    procedure SaveWorkspace() ;
    function  CloseWorkspace() : boolean; 
    procedure UpdateTreeview();

    procedure ApplicationMessage( var Msg:TMsg; var handled:boolean );
  end;


var
  mainForm: TmainForm;

implementation

uses FileCtrl, UWsConfigDlg, UProjConfigDlg,
     UOutputDlg, Clipbrd, MyUtils, SourceFiles, SimpleXML;

{$R *.DFM}


var
   homedir   : string;
   emptyNode : TTreeNode;
   wsNode    : TTreeNode;
   workspace : TWorkspace;
   lastWorkspace : string;
   sourceFileClicked : string;
   stayOnTop : boolean;
   lastProjectClicked : TProject;
   defaultWs : TWorkspaceCfg;   { default Workspace Config }
   defaultProj : TProjectCfg;   { default Project Config }


procedure UpdateProjectPopup; forward;
procedure LoadConfig; forward;
procedure SaveConfig ; forward;

procedure TMainForm.ApplicationMessage(var Msg: TMsg; var Handled: Boolean);
var
   xp, yp : Integer;
begin
  case Msg.Message of
  WM_MOVE, WM_WINDOWPOSCHANGING, WM_WINDOWPOSCHANGED : begin
    xp := LoWord( Msg.lParam );
    yp := LoWord( Msg.lParam );

    if xp < 20 then xp := 0;
    if yp < 20 then yp := 0;

    SetWindowPos( Self.Handle, 0,
                  xp , yp , mainForm.Width, mainForm.Height,
                  SWP_NOZORDER + SWP_NOSIZE     );
    handled:=true;
  end;
  end;
end;


procedure TmainForm.FormCreate(Sender: TObject);
//var  nx,ny : Integer; 
begin
  homedir := SysUtils.ExtractFilePath( ParamStr(0) );
  Application.OnMessage := MainForm.ApplicationMessage;
  {
  nx := Screen.Width - ( Self.Width + 1 );
  ny := Screen.Height - ( Self.Height+1 );
  SetWindowPos( Self.Handle, 0, nx, ny, 0, 0, SWP_NOSIZE or SWP_NOZORDER );
  }
  LoadConfig;
  UpdateTreeview();
end;





function ConfigFilename() : string;
begin
  Result := homedir + '.cfgx' ;
end;

function SelProject : boolean;
begin
  result:= Assigned( lastProjectClicked );
end;

function CurrentProject : TProject;
begin
  result:= lastProjectClicked;
end;

procedure SetCurrentProject(proj :TProject );
begin
  lastProjectClicked := proj;
  UpdateProjectPopup;
end;


procedure SetOnTop( b : boolean );
begin
  if b then
    SetWindowPos( mainForm.Handle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE or SWP_NOSIZE)
  else
    SetWindowPos( mainForm.Handle, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE or SWP_NOSIZE );
  StayOnTop := b;
  mainForm.StayonTopMenu.Checked := b;
end;


procedure TMainForm.ToggleMenuItem(Sender: TObject);
var
  menu : TMenuItem;
  N : Integer;
begin
  if not SelProject then Exit;
  menu := TMenuItem( Sender );
  N := VersionSubmenu.IndexOf( menu );
  if N<0 then Exit;
  menu.Checked := not menu.Checked;
  if menu.Checked then
    CurrentProject.enableVersion( N )
  else
    CurrentProject.disableVersion( N );

  CurrentProject.Save;
end;


procedure UpdateProjectPopup;
var
  vmenu, item : TMenuItem;
  proj : TProject;
  N : Integer;
  ver : string;
begin
  vmenu := mainForm.versionSubmenu;
  proj := CurrentProject;

  for N:=vmenu.Count-1 downto 0 do
  begin
    item := vmenu[N];
    vmenu.Remove( item );
    item.Free;
  end;

  vmenu.Enabled := SelProject and (proj.config.versions.Count > 0) ;
  if not SelProject then Exit;
  for N:=0 to proj.config.versions.Count-1 do
  begin
    ver := proj.config.versions[N];
    item:=NewItem( ver, 0, proj.CheckVersion(N), true, mainForm.ToggleMenuItem, 0, '' );
    vmenu.Add( item );
  end;
end;

{
NewSubMenu(const ACaption: string; hCtx: Word; const AName: string; Items: array of TMenuItem; AEnabled: Boolean)
}


procedure LoadConfig;
var
   xml : Node;
   str : string;
   top : boolean;
begin
  if FileExists( ConfigFilename() ) then begin
     xml := LoadXML( ConfigFilename() );
     if not Assigned( xml ) then Exit;

     lastWorkspace := xml.FindText( 'LastWorkspace' );

     str := xml.FindText( 'StayOnTop' );
     top := LowerCase(str) = 'true' ;
     SetOnTop( top );
     xml.Free;
  end;

  if FileExists( lastWorkspace ) and mainForm.CloseWorkspace then begin
     workspace := LoadWorkspace( lastWorkspace );
     if not Assigned( workspace ) then Exit;
     with mainForm do UpdatetreeView;
  end;
end;


procedure SaveConfig ;
var
  xml : Node;
begin
  xml := Node.Create( 'Defaults' );
  xml.Add( 'LastWorkspace', lastWorkspace );
  xml.AddBool( 'StayOnTop', StayOnTop );
  SaveXML( xml, ConfigFilename() );
  xml.Free;
end;


function SaveProject( proj: TProject ) : boolean;
begin
  if FileExists(proj.filename) then begin
    proj.Save;
    result:= true;
    Exit;
  end;
  
  Result:= false;
  with mainForm do begin
    SaveDialog.Filter:= 'Project Files(*.prx)|*.prx';
    SaveDialog.InitialDir := proj.basepath;
    SaveDialog.Filename := proj.name ;
    SaveDialog.Options := [ofHideReadOnly,ofPathMustExist,ofNoReadOnlyReturn];
    SaveDialog.Title:='Save Project File';
    if not SaveDialog.Execute then Exit;
    proj.SaveAs( ChangeFileExt( SaveDialog.Filename, '.prx' ) );
  end;
  result:= true;
end;


procedure TMainForm.CreateWorkspace ;
begin
  if Assigned(workspace) and ( not CloseWorkspace() ) then Exit;

  workspace := TWorkspace.Create;
  defaultWS.fromXML( workspace.config.toXML );
  wsConfigDlg.name.Text := '';
  wsConfigDlg.defaultCheckbox.Checked := false;
  wsConfigDlg.LoadOptions( workspace );
  if wsConfigDlg.ShowModal <> mrOk then begin
     workspace.Free;
     workspace:=nil;
     Exit;
  end;
  wsConfigDlg.SaveOptions( workspace );

  SaveDialog.InitialDir := homedir;
  SaveDialog.Filter := 'Workspace files(*.wsx)|*.wsx';
  SaveDialog.Options := [ofHideReadOnly,ofPathMustExist,ofNoReadOnlyReturn];
  SaveDialog.Title:='Save Workspace File';
  if not SaveDialog.Execute then begin
    workspace.Free;
    workspace := nil;
  end;

  workspace.SaveAs( ChangeFileExt( SaveDialog.FileName, '.wsx' ) );

  lastWorkspace := workspace.filename;
  mainForm.UpdateTreeview;    
  if wsConfigDlg.defaultCheckbox.Checked then begin
    workspace.config.fromXML( defaultWs.toXML );
  end;
  SaveConfig;
end;


procedure TMainForm.EditWorkspace ;
begin
  if not Assigned(workspace) then Exit;
  wsConfigDlg.defaultCheckbox.Checked :=false;
  wsConfigDlg.LoadOptions( workspace );
  if wsConfigDlg.ShowModal <> mrOk then  Exit;
  wsConfigDlg.SaveOptions( workspace );
  SaveWorkspace();

  if wsConfigDlg.defaultCheckbox.Checked then begin
    workspace.config.fromXML( defaultWS.toXML );
    SaveConfig;
  end;

  UpdateTreeview;
end;

function TMainForm.CloseWorkspace : boolean;
var
  msg : string;
  N : LongInt;
begin
  Result := true;
  if not Assigned( workspace ) then Exit;

  if not workspace.saved Then begin
    msg := 'Save Current Workspace (' + workspace.name + ') ?';
    N :=Application.MessageBox( PChar(msg) , 'Save Workspace', MB_YESNOCANCEL );
    case N of
      IDYES : workspace.Save;

      IDNO : ;

      IDCANCEL : begin
          Result:=false;
          Exit;
          end;
    end;
  end;
  
  workspace.Free;
  workspace := nil;
  UpdateTreeview;
  Result := true;
end;

procedure TMainForm.SaveWorkspace;
begin
  workspace.Save;
end;


procedure TMainForm.SelectWorkspace ;
var
  filename : string;
  dir : string;
begin
  dir := homedir;
  if Assigned( workspace ) then
  begin
    dir := ExtractFilePath( workspace.filename );
    if not DirectoryExists( dir ) then dir := homedir;
    if ( not CloseWorkspace ) then Exit;
  end;
  with( FileDialog) do begin
    InitialDir := dir;
    Filter := 'Workspace files(*.wsx)|*.wsx' ;
    Title := 'Load Workspace';
  end;
  if not FileDialog.Execute then Exit;
  filename := FileDialog.FileName;
  if not FileExists( filename ) then Exit;
  workspace := LoadWorkspace( filename );
  if not Assigned( workspace ) then Exit;
  lastWorkspace := workspace.filename ;
  SaveConfig;
  UpdateTreeview();
end;


function EditProject( pr : TProject ) : boolean;
begin
  Result:=false;
  if not Assigned( pr ) then Exit;
  ProjConfigDlg.projDir := pr.basepath;

  ProjConfigDlg.defaultCheckbox.Checked := false;
  ProjConfigDlg.LoadOptions( pr );
  if ProjConfigDlg.ShowModal <> mrOk then Exit;

  if Empty(pr.filename) then begin
    with MainForm.SaveDialog do begin
      Filter := 'Project files (*.prx)|*.prx';
      InitialDir := ProjConfigDlg.projectPath.Text;
      Title := 'Save Project File as...';
      Options := [ofOverwritePrompt,ofPathMustExist,ofEnableSizing];
    end;
    if not mainform.SaveDialog.Execute then Exit;
    pr.filename := ChangeFileExt( mainForm.SaveDialog.FileName, '.prx' );    
  end;
  
  Result:= true;
  ProjConfigDlg.SaveOptions( pr );
  pr.Save;
  
  if ProjConfigDlg.defaultCheckbox.Checked then begin
     pr.config.CopyTo( defaultProj );
     SaveConfig;
  end;
  
end;



procedure TmainForm.Quit1Click(Sender: TObject);
begin
   if CloseWorkspace = false then Exit;
   Application.Terminate;
end;

procedure TmainForm.Settings1Click(Sender: TObject);
begin
  EditWorkspace ;
end;

{
procedure TmainForm.New2Click(Sender: TObject);
}

function ExtractErrorMessage( line : string ) : string ;
var
  N : Integer;
begin
  result:= line;
  N := Pos( '):', line );
  if N>0 then result := Copy( line, N+2, Length(line)-N );
  if Length(result)>100 then result:=Copy(result,1,100 );
end;


procedure BuildTree( pnode : TTreeNode ; sources: TSourceFiles );
var
  tnode, fnode, enode : TTreeNode; { title node, file node, error node }
  I,N : Integer;
  str : string;
  elist : TStringList;
begin
  elist := TStringList.Create;

  with mainForm.treeview, sources do begin
    for N:= 0 to dfiles.Count-1 do begin
      str := ExtractFileName( dfiles[N] );
      if not FileExists( dfiles[N] ) then str := str + ' (missing) ';
      fnode :=Items.AddChild( pnode, str );
      //fnode.Hint := dfiles[N];
      fnode.ImageIndex:= 3;
      fnode.SelectedIndex := 3 ;
      fnode.data := Pointer( dfiles[N] );

      elist.Clear;
      if GetErrors( dfiles[N], elist ) then begin
        fnode.Text := Format( fnode.Text + ' (Errors:%d)', [elist.Count]) ;
        fnode.OverlayIndex := 2;
        for I:=0 to elist.Count-1 do begin
          enode :=Items.AddChild( fnode, ExtractErrorMessage( elist[I] ) );
          enode.ImageIndex := 2;
          enode.SelectedIndex :=2;
          enode.data := PChar(elist[I]);
        end;
        fnode.Collapse( true );
      end;
    end;

    N:= objfiles.Count + libfiles.Count;
    if N<1 then Exit;
    tnode := Items.AddChild( pnode, ObjHeaderText );
    tnode.ImageIndex := 1;
    tnode.SelectedIndex := 1;
    for N:= 0 to objfiles.Count-1 do begin
      str := ExtractFileName( objfiles[N] );
      if not FileExists( objfiles[N] ) then str := str + ' (missing) ';
      fnode :=Items.AddChild( tnode, str );
      //fnode.Hint := objfiles[N];
      fnode.data := Pointer( objfiles[N] );
      fnode.ImageIndex := 5;
      fnode.SelectedIndex :=5 ;
    end;
    for N:= 0 to libfiles.Count-1 do begin
      str := ExtractFileName( libfiles[N] );
      if not FileExists( libfiles[N] ) then str := str + ' (missing) ';
      fnode :=Items.AddChild( tnode, str  );
      //fnode.Hint := libfiles[N];
      fnode.data := Pointer( libfiles[N] );
      fnode.ImageIndex := 5;
      fnode.SelectedIndex := 5;      
    end;
    tnode.Collapse( true );
  end;


end;

procedure TMainForm.UpdateTreeview();
var
   N : Integer;
   proj : TProject;
   prjnode: TTreeNode;
   title, name : string;
begin

  if not Assigned( workspace ) then begin
    SaveAll1.Enabled := false;
    Settings1.Enabled := false;
    Save1.Enabled := false;
    Close1.Enabled := false;

    treeview.Items.BeginUpdate;
    treeview.items.Clear;
    emptyNode := treeview.Items.Add( nil, 'No Workspace Loaded' );
    emptyNode.ImageIndex := -1;
    emptyNode.SelectedIndex := -1;
    treeview.items.EndUpdate;
    Exit;
  end;

  SaveAll1.Enabled := true;
  Settings1.Enabled := true;
  Save1.Enabled := true;
  Close1.Enabled := true;

  title := 'Workspace : ' + workspace.name ;
  title := Format( title, [ workspace.projects.Count ] );

  treeView.Items.BeginUpdate;
  treeview.items.Clear;  
  wsNode := treeview.Items.Add( nil, title );
  wsNode.ImageIndex := 0;
  wsNode.SelectedIndex := 0;
  wsNode.Data := workspace;

  for N:= 0 to workspace.projects.Count-1 do
  begin
    proj := workspace.projects[N];
    title := 'Project : ' + proj.name ;
    prjnode := treeview.Items.AddChild( wsNode, title );
    prjnode.data := proj;
    prjnode.ImageIndex := 1;
    prjnode.SelectedIndex := 1;
    BuildTree( prjnode, proj.sources );
    if proj = CurrentProject then prjnode.Expand( true );
  end;

  for N:= 0 to workspace.failed.Count-1 do begin
    name := workspace.failed[N];
    title := ExtractFileName( name );
    title := ChangeFileExt( title, '' ) + ' (failed to load)';
    prjnode := treeview.Items.AddChild( wsNode, title );
    prjnode.ImageIndex := 1;
    prjnode.SelectedIndex := 1;
    prjnode.data := nil;
  end;

  wsNode.Expanded := True;
  treeview.items.EndUpdate;  
end;



procedure TmainForm.New1Click(Sender: TObject);
begin
  CreateWorkspace();
end;




procedure TmainForm.Load1Click(Sender: TObject);
begin
  if not CloseWorkspace then Exit;
  SelectWorkspace;
end;

procedure TmainForm.Close1Click(Sender: TObject);
begin
  CloseWorkspace;
  lastWorkspace := '';
  SaveConfig;
end;







procedure TmainForm.treeViewMouseDown(Sender: TObject;
          Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
   node : TTreeNode;
   canEdit : boolean;
begin
  { workspace must be loaded, right clicks only }
  if (not Assigned(workspace)) or (Button <> mbRight) then Exit;
  sourceFileClicked := '';
  SetCurrentProject( nil );

  node := treeview.GetNodeAt( X, Y );
  if not Assigned( node ) then Exit;
  treeview.Selected := node;

  { user clicks the workspace }
  if node = wsNode then begin
    SetCurrentProject( nil );
    with( Mouse.CursorPos ) do WorkspacePopup.Popup( X, Y );
    Exit;
  end;

  { User clicks a project }
  if node.Level=1 then begin
     SetCurrentProject( node.Data );
     if not Assigned(Node.data) then Exit;
     FullBuild1.Checked := CurrentProject.fullbuild;
     with( Mouse.CursorPos ) do ProjectPopup.Popup( X, Y );
     Exit;
  end;

  { user clicks a source file }
  if node.level = 2 then begin
    SetCurrentProject( node.parent.data );
  
    if node.text = ObjHeaderText then begin
      { TODO Add Popup here }
      Exit;
    end;
    sourceFileClicked :=  string( node.data );
    canEdit := FileExists( sourceFileClicked );    
    with SourcePopup do
    begin
      Compile1.Visible := canEdit;
      Edit1.Visible := canEdit;
      Remove1.Visible := true;
    end;
    with Mouse.CursorPos do SourcePopup.Popup( X, Y );
    Exit;
  end;

  { User clicks an Object file }
  if (node.Level = 3) and (node.parent.text = ObjHeaderText) then begin
    SetCurrentProject( TProject(node.parent.parent.data) );
    sourceFileClicked := string( node.data );
    with SourcePopup do
    begin
      Compile1.Visible := false;
      Edit1.Visible := false;
      Remove1.Visible := true;
    end;
    with Mouse.CursorPos do SourcePopup.Popup( X, Y );
  end;

  { user clicks a Source File Error }
  if (node.Level = 3) and (string(node.data) = ErrorHeaderText) then
  begin
    with SourcePopup do
    begin
      Compile1.Visible := false;
      Edit1.Visible := true;
      Remove1.Visible := true;
    end;
    with Mouse.CursorPos do SourcePopup.Popup( X, Y );
  end;
end;





procedure ExtractErrorInfo( line : string ; var fname : string; var lineno : Integer );
var
  num : string;
  lparen, rparen : Integer;

begin
  line := Trim( line );
  lineno := -1;
  if Length( line ) < 1 then Exit; // don't add blanks
  lparen := Pos( '(', line );
  rparen := Pos( ')', line );
  if (lparen<1) or (rparen<1) or (lparen>rparen) then Exit;
  num := Copy( line, lparen+1, rparen-lparen-1 );
  MyUtils.ParseInt( num, lineno ) ;
  fname := Copy( line, 1, lparen-1 );
end;






procedure TmainForm.treeViewDblClick(Sender: TObject);
var
  node :TTreeNode;
  lineno : Integer;
  line, fname : string;
begin
  if not Assigned( workspace ) then Exit;

  node := treeview.Selected;
  if not Assigned( node ) then Exit;
  if node.level = 2 then
  begin
    if node.Text = ObjHeaderText then Exit;
    sourceFileClicked := string(node.Data);
    workspace.EditFile( sourceFileClicked, -1 );
    //Self.WindowState := wsMinimized;
    Exit;
  end;

  { user clicks a File }
  if (node.Level = 3) and (node.parent.text <> ObjHeaderText) then 
  begin
    sourceFileClicked := string(node.parent.data);
    SetCurrentProject( TProject( node.parent.parent.data ) );
    line := PChar( node.data );
    ExtractErrorInfo( line, fname, lineno );
    if not FileExists( fname ) then fname := sourceFileClicked;
    workspace.EditFile( fname, lineno );
    //Self.WindowState := wsMinimized;    
  end;
end;


procedure TmainForm.PMNewProjectClick(Sender: TObject);
var
  proj : TProject;
begin
  proj := TProject.Create;
  proj.basepath := homedir;
  defaultProj.CopyTo( proj.config );
  if EditProject( proj ) then begin
    workspace.Add( proj );
    SaveWorkspace;
    UpdateTreeview;
  end
  else proj.Free;
end;


procedure TmainForm.Settings2Click(Sender: TObject);
var
  proj : TProject;
begin
  proj := treeview.Selected.Data;
  if EditProject( proj ) then proj.Save;
  UpdateTreeview;
end;

procedure TmainForm.Save1Click(Sender: TObject);
begin
  if not Assigned(workspace) then Exit;
  workspace.Save;
end;

procedure TmainForm.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
  CanClose := CloseWorkspace ;
end;

procedure TmainForm.PMSettingsClick(Sender: TObject);
begin
  if not Assigned( workspace ) then Exit;
  EditWorkspace;
end;

procedure TmainForm.PMCloseClick(Sender: TObject);
begin
  if not CloseWorkspace then Exit;
  lastWorkspace := '';
  SaveConfig;
end;

procedure TmainForm.PMLoadProjectClick(Sender: TObject);
var
  proj : TProject;
  filename : string;
begin
  if not Assigned( workspace ) then Exit;
  with( FileDialog ) do
  begin
    InitialDir := ExtractFilePath( workspace.filename );
    FileName:= '';
    Filter := 'Project files(*.prx)|*.prx' ;
    Title := 'Add Project';
  end;
  if not FileDialog.Execute then Exit;
  filename := FileDialog.FileName;
  if not FileExists( filename ) then Exit;
  proj := workspace.FindProject( filename );
  if Assigned( proj ) then Exit;
  proj := LoadProject( filename );
  if not Assigned( proj ) then Exit;
  workspace.Add( proj );
  workspace.Save;
  //workspace.saved := false;
  UpdateTreeview();
end;

procedure TmainForm.Close2Click(Sender: TObject);
var
  node : TTreeNode;
  proj : TProject;
begin
  node := treeview.Selected;
  if node.Parent <> wsNode then Exit;
  proj := node.Data;
  if workspace.projects.IndexOf( proj ) < 0 then Exit;
  workspace.projects.Remove( proj );
  workspace.Save;
  proj.Free;
  UpdateTreeview; 
end;

procedure TmainForm.Add1Click(Sender: TObject);
var
  proj :TProject;
  node :TTreeNode;
  N : Integer;
begin
  node := treeview.Selected;
  if not Assigned( node ) then Exit;
  proj := node.Data;
  FileDialog.FileName := '';
  FileDialog.InitialDir := proj.basepath;
  FileDialog.DefaultExt := '';
  FileDialog.Options := [];
  FileDialog.Title := 'Add Files to Project';
  FileDialog.Filter := 'D Source Files|*.d|OBJ Files|*.obj|LIB Files|*.lib';
  FileDialog.Options := [ofAllowMultiSelect , ofPathMustExist , ofCreatePrompt, ofHideReadOnly];

  if not FileDialog.Execute then Exit;
  with FileDialog do
  for N:= 0 to FileDialog.Files.Count-1 do begin
    if Not proj.sources.HasFile( Files[N] ) then proj.Add( Files[N] );
  end;
  proj.Save;
  UpdateTreeview;
end;



procedure TmainForm.SaveAll1Click(Sender: TObject);
var
  N : Integer;
  proj : TProject;
begin
  SaveWorkspace;
  for N:=0 to workspace.projects.Count-1 do begin
    proj:= workspace.projects[N];
    proj.Save;
  end;
end;


procedure TmainForm.Remove1Click(Sender: TObject);
begin
  if not SelProject then Exit;
  if Empty( sourceFileClicked ) then Exit;
  with CurrentProject do
   if not sources.HasFile( sourceFileClicked ) then Exit;

  if Application.MessageBox( PChar('Remove file from Project? (file will not be deleted)'),
     'Confirm Remove', MB_YESNO ) <> ID_YES then Exit;  

  CurrentProject.sources.Remove( sourceFileClicked );
  SaveProject( CurrentProject ); 
  UpdateTreeview;
  sourceFileClicked := '';  
end;



procedure TmainForm.Compile1Click(Sender: TObject);
var
  msg : string;
  destfile : string;
begin
  if not Assigned( workspace ) then Exit;
  if not SelProject then exit;
  if Empty( sourceFileClicked ) then Exit;

  if not FileExists(sourceFileClicked) then
  begin
    msg := 'File ' + sourceFileClicked + ' could not be found';
    Application.MessageBox( PChar( msg ), 'File not found', MB_OK );
    Exit;
  end;

  if not FileExists(workspace.config.compiler) then
  begin
    msg := 'Compiler ' + workspace.config.compiler + ' could not be found';
    Application.MessageBox( PChar( msg ), 'D Compiler not found', MB_OK );
    Exit;
  end;

  destfile := CurrentProject.GetResultFile( sourcefileclicked );
  workspace.CompileFile( CurrentProject, sourceFileClicked );
  UpdateTreeview;
  StatusBar.SimpleText:='';
  StatusBar.SimplePanel := true;
  if FileExists( destfile ) then  StatusBar.SimpleText := 'Compile successful';
 end;

procedure TmainForm.PMSaveClick(Sender: TObject);
begin
  SaveWorkspace;
end;

procedure TmainForm.Edit1Click(Sender: TObject);
var
  msg : string;
begin
  if not Assigned( workspace ) then Exit;
  if not SelProject then Exit;
  if FileExists(sourceFileClicked) then
  begin
    workspace.EditFile( sourceFileClicked, -1 );
    //Self.WindowState := wsMinimized;    
  end
  else begin
    msg := 'File ' + sourceFileClicked + ' could not be found.';
    Application.MessageBox( PChar(msg), 'File not found', MB_OK )
  end;
end;


procedure TmainForm.SaveProject1Click(Sender: TObject);
begin
  if not Assigned(workspace) then Exit;
  if not SelProject then Exit;
  SaveProject( CurrentProject ); 
end;

procedure TmainForm.BuildMenuClick(Sender: TObject);
begin
  if not Assigned( workspace ) then Exit;
  if not SelProject then Exit;
  workspace.BuildProjectEXE( CurrentProject ) ;
  UpdateTreeview;
  OutputDlg.Listbox.Items.Clear;
  OutputDlg.ShowOutput( CurrentProject, workspace.output, 'Build EXE Results' );
end;

procedure TmainForm.BuildSubMenuClick(Sender: TObject);
begin
  if not Assigned( workspace ) then Exit;
  if not SelProject then Exit;
  workspace.BuildProjectEXE( CurrentProject );
  UpdateTreeview;
  OutputDlg.Listbox.Items.Clear;
  OutputDlg.ShowOutput( CurrentProject, workspace.output, 'Build EXE Results' );
end;

procedure TmainForm.BuildLibMenuClick(Sender: TObject);
begin
  if not SelProject then Exit;
  if FileExists( CurrentProject.LibName ) then DeleteFile( CurrentProject.LibName );  
  workspace.BuildProjectLIB( CurrentProject );
  UpdateTreeview;
  OutputDlg.Listbox.Items.Clear;
  OutputDlg.ShowOutput( CurrentProject, workspace.output, 'Build LIB Results' );
end;

procedure TmainForm.Refresh1Click(Sender: TObject);
begin
  UpdateTreeview;
end;



procedure TmainForm.Build1Click(Sender: TObject);
begin
  if not SelProject then Exit;
  if FileExists( CurrentProject.ExeName ) then DeleteFile( CurrentProject.ExeName );
  workspace.BuildProjectEXE( CurrentProject ) ;
  UpdateTreeview;
  OutputDlg.Listbox.Clear;
  OutputDlg.ShowOutput( CurrentProject, workspace.output, 'Build EXE Results' );
end;



procedure TmainForm.About1Click(Sender: TObject);
begin
  Application.MessageBox( PChar( 'DManager Beta (c) David Medlock, 2005' ), 'About', 0 ); 
end;

procedure TmainForm.FullBuild1Click(Sender: TObject);
begin
  if not SelProject then Exit;
  CurrentProject.fullbuild := not FullBuild1.Checked;
  FullBuild1.Checked := not FullBuild1.Checked;
  CurrentProject.Save;
end;

procedure TmainForm.BuildRun1Click(Sender: TObject);
var
  output : TStringList;
begin
  if not SelProject then Exit;
  workspace.BuildProjectEXE( CurrentProject ) ;
  UpdateTreeview;

  if not FileExists( CurrentProject.ExeName ) then
  begin
    workspace.output.Add( '**** Executable could not be built.  Correct errors or try a full build' );
    OutputDlg.ShowOutput( CurrentProject, workspace.output, 'Build EXE Results' );
    Exit;
  end;

  output := TStringList.Create;
  output.AddStrings( workspace.output );
  mainForm.WindowState := wsMinimized ;
  ConsoleApp( CurrentProject.ExeName, '', output );
  mainForm.WindowState := wsNormal ;  
  OutputDlg.Listbox.Clear;
  OutputDlg.ShowOutput( CurrentProject, output, 'Build/Run of ' + CurrentProject.ExeName );
  output.Free;
end;

procedure TmainForm.StayonTopMenuClick(Sender: TObject);
begin
  SetOnTop( not UMain.StayonTop );
  SaveConfig;
end;

initialization
   lastWorkspace:= '';
   defaultWs := TWorkspaceCfg.Create;
   defaultProj := TProjectCfg.Create;

finalization
   if Assigned( workspace ) then workspace.Free;
   defaultWs.Free;
   defaultProj.Free;

end.