<PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
        <Cfg_2>true</Cfg_2>
        <CfgParent>Base</CfgParent>
        <Base>true</Base>
    </PropertyGroup>
    <Import Project="..\Version.optset" Condition="'$(Base)'!='' And Exists('..\Version.optset')"/>
    <PropertyGroup Condition="'$(Base)'!=''">
        <DCC_UNIT_PLATFORM>false</DCC_UNIT_PLATFORM>
        <DCC_SYMBOL_PLATFORM>false</DCC_SYMBOL_PLATFORM>
        <DCC_CBuilderOutput>All</DCC_CBuilderOutput>
        <GenPackage>true</GenPackage>

        <GenDll>true</GenDll>
        <SanitizedProjectName>VCSInfo</SanitizedProjectName>
        <DCC_DcuOutput>.\$(Platform)\$(Config)</DCC_DcuOutput>
        <DCC_ExeOutput>.\$(Platform)\$(Config)</DCC_ExeOutput>
        <DCC_E>false</DCC_E>
        <DCC_N>false</DCC_N>
        <DCC_S>false</DCC_S>
        <DCC_F>false</DCC_F>
        <DCC_K>false</DCC_K>



        <VerInfo_Locale>1033</VerInfo_Locale>
        <CfgDependentOn>..\Version.optset</CfgDependentOn>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Base_Android)'!=''">
        <EnabledSysJars>android-support-v4.dex.jar;apk-expansion.dex.jar;cloud-messaging.dex.jar;fmx.dex.jar;google-analytics-v2.dex.jar;google-play-billing.dex.jar;google-play-licensing.dex.jar;google-play-services.dex.jar</EnabledSysJars>
        <DCC_UsePackage>rtl;$(DCC_UsePackage)</DCC_UsePackage>
        <DCC_CBuilderOutput>None</DCC_CBuilderOutput>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Base_iOSDevice32)'!=''">

        <DCC_DebugDCUs>true</DCC_DebugDCUs>
        <DCC_Optimize>false</DCC_Optimize>
        <DCC_GenerateStackFrames>true</DCC_GenerateStackFrames>
        <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
        <DCC_RemoteDebug>true</DCC_RemoteDebug>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Cfg_1_Win32)'!=''">
        <VerInfo_MajorVer>0</VerInfo_MajorVer>
        <VerInfo_PreRelease>true</VerInfo_PreRelease>
        <VerInfo_DLL>true</VerInfo_DLL>
        <VerInfo_MinorVer>1</VerInfo_MinorVer>
        <DCC_RemoteDebug>false</DCC_RemoteDebug>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Cfg_2)'!=''">
        <DCC_LocalDebugSymbols>false</DCC_LocalDebugSymbols>
        <DCC_Define>RELEASE;$(DCC_Define)</DCC_Define>
        <DCC_SymbolReferenceInfo>0</DCC_SymbolReferenceInfo>
        <DCC_DebugInformation>0</DCC_DebugInformation>

                </DeployFile>
                <DeployFile LocalName="C:\Users\Public\Documents\Embarcadero\Studio\15.0\Bpl\VCSInfo.bpl" Configuration="Debug" Class="ProjectOutput">
                    <Platform Name="Win32">
                        <RemoteName>VCSInfo.bpl</RemoteName>
                        <Overwrite>true</Overwrite>
                    </Platform>
                </DeployFile>
                <DeployClass Name="ProjectiOSDeviceResourceRules"/>









                <DeployClass Name="ProjectOSXResource">
                    <Platform Name="OSX32">
                        <RemoteDir>Contents\Resources</RemoteDir>
                        <Operation>1</Operation>
                    </Platform>
                </DeployClass>
                <DeployClass Name="AndroidClassesDexFile">

                </DeployClass>
                <DeployClass Name="Android_LauncherIcon36">
                    <Platform Name="Android">
                        <RemoteDir>res\drawable-ldpi</RemoteDir>
                        <Operation>1</Operation>
                    </Platform>
                </DeployClass>
                <DeployClass Name="DependencyModule">
                    <Platform Name="Win32">
                        <Operation>0</Operation>
                        <Extensions>.dll;.bpl</Extensions>
                    </Platform>
                    <Platform Name="OSX32">
                        <Operation>1</Operation>
                        <Extensions>.dylib</Extensions>
                    </Platform>
                </DeployClass>
                <ProjectRoot Platform="Win64" Name="$(PROJECTNAME)"/>
                <ProjectRoot Platform="iOSDevice64" Name="$(PROJECTNAME).app"/>
                <ProjectRoot Platform="iOSDevice32" Name="$(PROJECTNAME).app"/>
                <ProjectRoot Platform="Win32" Name="$(PROJECTNAME)"/>
                <ProjectRoot Platform="OSX32" Name="$(PROJECTNAME)"/>
                <ProjectRoot Platform="Android" Name="$(PROJECTNAME)"/>
                <ProjectRoot Platform="iOSSimulator" Name="$(PROJECTNAME).app"/>

      FImgSyncPull: integer;
      FImgSyncPush: integer;
      FImgSyncBoth: integer;
      FImgClean: integer;
      FImgPending: integer;
      FImgExtra: integer;

      function GetActiveFileName: string;
      function GetRepoInfo(const AFileName: string; const AForceUpdate: Boolean = False): TRepoInfo;


      function GetActiveFileRepo(const AForceUpdate: Boolean; out AFileName: string): TRepoInfo; overload;
      function GetActiveFileRepo(const AForceUpdate: Boolean = False): TRepoInfo; overload; inline;

      procedure LogMessage(const Text: string); overload;
      procedure LogMessage(const Text: string; const Args: array of const); overload;

      procedure RefreshSyncStatus(const actSync: TAction);

      procedure actSyncExecute(Sender: TObject);
      procedure actSyncUpdate(Sender: TObject);
      procedure actStatusExecute(Sender: TObject);
      procedure actStatusUpdate(Sender: TObject);
      procedure actInfoExecute(Sender: TObject);
      procedure actInfoUpdate(Sender: TObject);
      procedure actInfoMenuPopup(Sender: TObject);
      procedure actInfoMenuVCSClick(Sender: TObject);
  end;

procedure Register;

implementation
uses
  System.SysUtils, System.UITypes, System.Classes, System.StrUtils,
  Winapi.Windows, Winapi.ShellAPI,
  Vcl.Forms, Vcl.Dialogs, Vcl.Graphics,
  u_FinalPathName;

const
  scMenuIDString = 'net.2of4.VCSInfoWizard';
  cLimit = 9;

{ ------------------------------------------------------------------------------------------------ }
procedure Register;
begin
  RegisterPackageWizard(TVCSInfoWizard.Create);
  (* TODO: create multiple separate menu wizards:
    - pull (incoming) / push (outgoing)

  Dummy := '';
  Result := InternalExecute(CommandLine, Dummy, OutputLineCallback, RawOutput, AbortPtr, CurrentDir);
end;

{$ENDREGION}

{ ------------------------------------------------------------------------------------------------ }
function CreateProcess(const ACommand: string; const ACurrentDir: string = ''; const AShow: boolean = False): boolean;
var
  SUI: TStartupInfo;
  Command: string;
  ProcInfo: TProcessInformation;
begin
  try
    SUI := Default(TStartupInfo);
    SUI.cb := SizeOf(SUI);
    if not AShow then begin
      SUI.dwFlags := STARTF_USESHOWWINDOW;
      SUI.wShowWindow := SW_MINIMIZE;
    end;
    Command := ACommand;
    UniqueString(Command);
    Result := Winapi.Windows.CreateProcess(nil, PChar(Command), nil, nil, False,
                                            CREATE_UNICODE_ENVIRONMENT,
                                            nil,
                                            PChar(ACurrentDir),
                                            SUI, ProcInfo);

    finally
      Icon.Free;
    end;
    if ShouldDestroy then
      DestroyIcon(IconHandle);
  end {AddExeIcon};
  { - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - }
  function AddButtonMenuItem(const Button: TToolButton; ImageIndex: integer; Caption: string;
                             const OnClick: TNotifyEvent = nil): TMenuItem;
  begin
    Result := TMenuItem.Create(Button.DropdownMenu);
    Result.Caption := Caption;
    Result.ImageIndex := ImageIndex;
    Result.OnClick := OnClick;
    Button.DropdownMenu.Items.Add(Result);
  end;
  { - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - }
const
  scToolbarName = 'tlbVCSInfo';
var
  Toolbar: TWinControl;

  AddButtonMenuItem(Button, FImgSyncPush, 'Outgoing changesets (push)');
  AddButtonMenuItem(Button, FImgSyncBoth, 'Incoming and outgoing changesets');
  AddButtonMenuItem(Button, -1,           '-');
  AddButtonMenuItem(Button, FImgClean,    'Working dir is clean');
  AddButtonMenuItem(Button, FImgPending,  'Working dir has changes');
  AddButtonMenuItem(Button, FImgExtra,    'Working dir has untracked files');
  AddButtonMenuItem(Button, -1,           '-');
  AddButtonMenuItem(Button, FImgIcon,     GetCurrentVersion, actInfoMenuVCSClick);


  LogMessage('Creating sync button...');
  actSync := TAction.Create(FToolbar);
  actSync.Caption := 'Nothing to sync';
  actSync.Hint := actSync.Caption;
  actSync.Enabled := True;

  Output: string;
begin
  try
    Menu := Sender as TPopupMenu;
    if Menu.Owner is TToolButton then begin
      Item := Menu.Items.Items[Menu.Items.Count - 1];
      Button := TToolButton(Menu.Owner);
      Item.ImageIndex := Button.ImageIndex;
      case Button.Action.Tag of
        0: begin // hg

          ExecuteCmd('thg version', Output);
          if Output <> '' then
            Item.Caption := Output.Split([#13#10, #10, #13], 1, TStringSplitOptions.ExcludeEmpty)[0];
        end;
        1: begin // fossil

          ExecuteCmd('fossil version', Output);
          if Output <> '' then
            Item.Caption := Output.Replace('This is f', 'F').TrimRight;
        end;
        else begin

          Item.Caption := GetCurrentVersion;
        end;
      end;
    end;
  except
    on E: Exception do begin
      LogMessage('actInfoMenuPopUp raised ' + E.ClassName + sLineBreak + E.ToString);
    end;
  end;
end {TVCSInfoWizard.actInfoMenuPopup};

procedure TVCSInfoWizard.actInfoUpdate(Sender: TObject);
var
  actInfo: TAction;
  Repo: TRepoInfo;
  NewImageIndex: integer;
  NewCaption: string;
begin
  try
    actInfo := Sender as TAction;
    Repo := GetActiveFileRepo;
    actInfo.Tag := IndexStr(Repo.RepoType, ['hg', 'fossil']);
    case actInfo.Tag of
      0: begin
        NewImageIndex := FImgMercurial;
        NewCaption := 'Mercurial';
      end;
      1: begin
        NewImageIndex := FImgFossil;
        NewCaption := 'Fossil';

    end;
  except
    on E: Exception do begin
      LogMessage('actInfoUpdate raised ' + E.ClassName + sLineBreak + E.ToString);
    end;
  end;
end;

procedure TVCSInfoWizard.actInfoMenuVCSClick(Sender: TObject);
var
  Dir: string;
begin
  Dir := ExtractFileDir(GetActiveFileName);
  case (((Sender as TMenuItem).Owner as TComponent).Owner as TToolButton).Action.Tag of
    0: begin // hg
      CreateProcess('cmd.exe /k hg', Dir, True);
    end;
    1: begin // fossil
      CreateProcess('cmd.exe /k fossil', Dir, True);
    end;
  end;
end;

procedure TVCSInfoWizard.actBranchExecute(Sender: TObject);
var
  P: TPoint;
begin
  with FButtonBranch.BoundsRect do
    P := FButtonBranch.Parent.ClientToScreen(Point(Left, Bottom));

  if Repo.IsRepo then begin
    if Repo.Incoming = 0 then begin
      NewImageIndex := FImgSyncNone;
      if Repo.Outgoing = 0 then begin
        NewCaption := 'Nothing to sync';
      end else if Repo.Outgoing > 0 then begin
        NewImageIndex := FImgSyncPush;
        if Repo.Outgoing = cLimit then begin
          NewCaption := Format('%d+ push(es)', [Repo.Outgoing]);
        end else begin
          NewCaption := Format('%d push(es)', [Repo.Outgoing]);
        end;
      end else begin // Repo.Outgoing < 0
        NewImageIndex := FImgUnknown;
        NewCaption := 'No pulls, pushes unknown';
      end;
    end else if Repo.Incoming > 0 then begin
      NewImageIndex := FImgSyncPull;
      if Repo.Incoming = cLimit then begin
        NewCaption := Format('%d+ pull(s)', [Repo.Incoming]);
      end else begin
        NewCaption := Format('%d pull(s)', [Repo.Incoming]);
      end;
      if Repo.Outgoing > 0 then begin
        NewImageIndex := FImgSyncBoth;
        if Repo.Outgoing = cLimit then begin
          NewCaption := Format('%s, %d+ push(es)', [NewCaption, Repo.Outgoing]);
        end else begin
          NewCaption := Format('%s, %d push(es)', [NewCaption, Repo.Outgoing]);
        end;
      end else if Repo.Outgoing < 0 then begin
        NewCaption := Format('%s, pushes unknown', [NewCaption]);
      end;
    end else begin // Repo.Incoming < 0
      NewImageIndex := FImgUnknown;
      NewCaption := 'Pulls unknown';
      if Repo.Outgoing = 0 then begin

{ ------------------------------------------------------------------------------------------------ }
function TVCSInfoWizard.GetState: TWizardState;
var
  Repo: TRepoInfo;
begin
  Result := [];
  Repo := GetActiveFileRepo;
  // wsEnabled if the current module is located inside a working directory
  if Repo.IsRepo then begin
    Include(Result, wsEnabled);
    // wsChecked if the current module has incoming or outgoing changes
    if (Repo.Incoming + Repo.Outgoing > 0) then begin
      Include(Result, wsChecked);
    end;

end;

{ ------------------------------------------------------------------------------------------------ }
function TVCSInfoWizard.GetName: string;
begin
  Result := scMenuIDString;
end;

function TVCSInfoWizard.GetActiveFileName: string;
var
  Modules: IOTAModuleServices;
  Module: IOTAModule;
  Editor: IOTAEditor;
  Project: IOTAProject;
begin
  Result := '';
  Modules := ToolsAPI.BorlandIDEServices as IOTAModuleServices;
  Module := Modules.CurrentModule;
  if Assigned(Module) then begin
    Editor := Module.CurrentEditor;
    if Assigned(Editor) then
      Result := Editor.FileName
    else
      Result := Module.FileName;
  end;
  if Result = '' then begin
    Project := ToolsAPI.GetActiveProject;
    if Assigned(Project) then
      Result := Project.FileName;
  end;
end {GetActiveFileName};

function TVCSInfoWizard.GetActiveFileRepo(const AForceUpdate: Boolean): TRepoInfo;
var
  FileName: string;
begin
  Result := GetActiveFileRepo(AForceUpdate, FileName);
end;

function TVCSInfoWizard.GetActiveFileRepo(const AForceUpdate: Boolean; out AFileName: string): TRepoInfo;




begin





  AFileName := GetActiveFileName;

  if FileExists(AFileName) then begin
    Result := GetRepoInfo(AFileName, AForceUpdate);



  end else begin
    Result := Default(TRepoInfo);
  end;
end {TVCSInfoWizard.GetActiveFileRepo};






















function TVCSInfoWizard.GetRepoInfo(const AFileName: string; const AForceUpdate: Boolean): TRepoInfo;
const
  cRefreshSeconds = 10;
var
  FilePath, FinalFilePath, RootPath, FinalRootPath: string;
  Lines: TStringList;
  Line: string;

          if iRes = 0 then begin
            Result.Pending := Lines.Count;
          end else begin
            Result.Pending := -1;
          end;

          Lines.Clear;
          iRes := ExecuteCmd('hg -yq incoming --newest-first --template "{rev}\n" --limit ' + IntToStr(cLimit),
                             Lines.Append, False, nil, FilePath);
          if iRes < 255 then begin
            Result.Incoming := Lines.Count;
          end else begin
            Result.Incoming := -1;
          end;

          Lines.Clear;
          iRes := ExecuteCmd('hg -yq outgoing --newest-first --template "{rev}\n" --limit ' + IntToStr(cLimit),
                             Lines.Append, False, nil, FilePath);
          if iRes < 255 then begin
            Result.Outgoing := Lines.Count;
          end else begin
            Result.Outgoing := -1;
          end;
        finally