CodeSnip Old Code (SVN)

{
 * USaveSourceDlg.pas
 *
 * Implements customised Save dialog box for source code. Dialog has additional
 * controls to allow user to choose output file format, commenting style and
 * syntax highlighting.
 *
 * Unit originally named USaveSnippetDlg.pas. Renamed as USaveSourceDlg.pas as
 * at v1.1.
 *
 * $Rev$
 * $Date$
 *
 * ***** BEGIN LICENSE BLOCK *****
 *
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with the
 * License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
 * the specific language governing rights and limitations under the License.
 *
 * The Original Code is USaveSourceDlg.pas
 *
 * The Initial Developer of the Original Code is Peter Johnson
 * (http://www.delphidabbler.com/).
 *
 * Portions created by the Initial Developer are Copyright (C) 2005-2010 Peter
 * Johnson. All Rights Reserved.
 *
 * Contributor(s)
 *   NONE
 *
 * ***** END LICENSE BLOCK *****
}


unit USaveSourceDlg;


interface


uses
  // Delphi
  Classes, StdCtrls, ExtCtrls,
  // Project
  USaveDialogEx, USourceGen;


type

  {
  THiliteQuery:
    Type of handler for event triggered by TSaveSourceDlg to check if a file
    type supports syntax highlighting.
      @param Sender [in] TSaveSourceDlg dialog object triggering event.
      @param Ext [in] Extension of file type being checked.
      @param CanHilite [in/out] Flag that handler sets true if syntax
        highlighting supported (default value is False).
  }
  THiliteQuery = procedure(Sender: TObject; const Ext: string;
    var CanHilite: Boolean) of object;

  {
  TSaveSourceDlg:
    Extended save dialog box used when saving code snippets. It displays
    additional controls used to specify attributes of source code. Requires
    SAVESNIPPETEXT dialog resource. Dialog also adjusts any file name entered
    without extension to include extension associated with any current filter.
  }
  TSaveSourceDlg = class(TSaveDialogEx)
  strict private
    fPanel: TPanel;               // Panel thats hold controls added to dialog
    fLblCommentStyle: TLabel;     // Label for comment style combo
    fCmbCommentStyle: TComboBox;  // Combo box used to select commenting style
    fChkSyntaxHilite: TCheckBox;  // Check box that toggles syntax highlighting
    fHelpBtn: TButton;            // Help button added to dialog
    fPreviewBtn: TButton;         // Preview button added to dialog
    fCommentStyle: TCommentStyle; // Style of commenting to be used source code
    fOnPreview: TNotifyEvent;     // Event handler for OnPreview event
    fOnHiliteQuery: THiliteQuery; // Event handler for OnHiliteQuery event
    fUseSyntaxHiliting: Boolean;  // Flags whether source is syntax highlighted
    fSelectedFilterIdx: Integer;  // Store index of selected file type.
    procedure HelpClickHandler(Sender: TObject);
      {Handles click on help button. Calls help with required keyword.
        @param Sender [in] Not used.
      }
    procedure PreviewClickHandler(Sender: TObject);
      {Handles click on preview button. Updates properties then triggers
      dialog's OnPreview event.
        @param Sender [in] Not used.
      }
    procedure SetOnPreview(const Value: TNotifyEvent);
      {Write accessor for OnPreview event. Enables / disables preview button
      depending on if event handler assigned.
        @param Value [in] Required event handler.
      }
    procedure UpdateSyntaxHiliting;
      {Updates value of UseSyntaxHiliting property per state of dialog box
      controls.
      }
    procedure UpdateCommentStyle;
      {Selects appropriate item in comment style combo box per current comment
      style property.
      }
    procedure CommentStyleChange(Sender: TObject);
      {Comment style combo box OnChange event handler. Updates CommentStyle
      property.
        @param Sender [in] Not used.
      }
    function GetSelectedExt: string;
      {Read accessor for SelectedExt property. Extracts extension for selected
      file type from Filter property.
        @return Selected extension with leading '.'.
      }
    function AdjustFileName(const AFileName: string): string;
      {Adjusts any file name supplied without an extension by appending
      extension associated with the currently selected file type. If the file
      has an extension or if the file type is *.* then the file name is not
      changed.
        @param AFileName [in] File name to be adjusted.
        @return Adjusted file name.
      }
    function GetFilterIndex: Integer;
      {Gets index of selected filter.
        @return Selected filter index.
      }
    procedure SetFilterIndex(const Value: Integer);
      {Records index of selected file filter.
        @param Value [in] New value of selected file filter.
      }
  strict protected
    procedure DoClose; override;
      {Tidies up and sets properties from controls when dialog is about to
      close.
      }
    function DoCanClose: Boolean; override;
      {Called to check if dialog can close. We check for existing file (after
      adding required extension) and inhibit closure if file exists and user
      doesn't want to overwrite.
        @return True if dialog can close and false otherwise.
      }
    procedure DoShow; override;
      {Sets up dialog just before it is displayed.
      }
    procedure DoTypeChange; override;
      {Notifies when a different file type is selected in file type combo box.
      Checks if syntax highlighting supported for selected file type.
      }
  public
    constructor Create(AOwner: TComponent); override;
      {Class constructor. Creates dialog box and adds custom controls to it.
        @param AOwner [in] Owning component. Dialog box will be aligned over
          AOwner.
      }
    function Execute: Boolean; override;
      {Displays dialog box. Sets required dialog box template if new style
      dialogs being used. Adjusts any extension-less file name to have extension
      of selected file type.
        @return True if user OKs and false if cancels.
      }
    property SelectedExt: string
      read GetSelectedExt;
      {Extension relating to selected file type}
  published
    property CommentStyle: TCommentStyle
      read fCommentStyle write fCommentStyle;
      {Commenting style selected in dialog box. Determines default comment style
      selection in dialog box when set}
    property UseSyntaxHiliting: Boolean
      read fUseSyntaxHiliting write fUseSyntaxHiliting;
      {Flag true if syntax highlighting is to be used when saving / previewing
      the source code. This is case when check box is checked and selected file
      type supports highlighting. Set the property to check the box}
    property OnPreview: TNotifyEvent
      read fOnPreview write SetOnPreview;
      {Event triggered when preview button clicked. Handlers should display file
      that will be generated when Save button is clicked}
    property OnHiliteQuery: THiliteQuery
      read fOnHiliteQuery write fOnHiliteQuery;
      {Event triggered when a file type is selected. Handlers should determine
      if the file type supports syntax highlighting}
    property FilterIndex: Integer read GetFilterIndex write SetFilterIndex;
      {Re-implementation of inherited property. Used to overcome apparent bug
      where property forgets selected filter when dialog box is closed}
  end;


implementation


uses
  // Delphi
  SysUtils, Forms, Dialogs, Dlgs, Controls, Windows,
  // Project
  UConsts, UMessageBox, UOpenDialogHelper, UStructs;


resourcestring
  // Component captions
  sLblCommentStyle = 'Comment style:';
  sChkSyntaxHilite = 'Use syntax highlighting';
  sBtnPreview = '&Preview...';
  sBtnHelp = '&Help';

  
const
  // Name of dialog box template resource ** do not localise
  cTemplateName = 'SAVESNIPPETEXT';


{ TSaveSourceDlg }

function TSaveSourceDlg.AdjustFileName(const AFileName: string): string;
  {Adjusts any file name supplied without an extension by appending extension
  associated with the currently selected file type. If the file has an extension
  or if the file type is *.* then the file name is not changed.
    @param AFileName [in] File name to be adjusted.
    @return Adjusted file name.
  }
begin
  Result := AFileName;
  if ExtractFileExt(Result) = '' then
  begin
    if SelectedExt <> '.*' then
      Result := Result + SelectedExt;
  end;
end;

procedure TSaveSourceDlg.CommentStyleChange(Sender: TObject);
  {Comment style combo box OnChange event handler. Updates CommentStyle
  property.
    @param Sender [in] Not used.
  }
begin
  fCommentStyle := TCommentStyle(
    fCmbCommentStyle.Items.Objects[fCmbCommentStyle.ItemIndex]
  );
end;

constructor TSaveSourceDlg.Create(AOwner: TComponent);
  {Class constructor. Creates dialog box and adds custom controls to it.
    @param AOwner [in] Owning component. Dialog box will be aligned over AOwner.
  }
begin
  inherited Create(AOwner);

  // Create additional controls
  // (Order of creation is important - tab order is reverse of creation order)

  // panel that stores all extra controls
  fPanel := TPanel.Create(Self);
  fPanel.Caption := '';
  fPanel.BevelOuter := bvNone;
  fPanel.TabStop := True;

  // custom help button
  fHelpBtn := TButton.Create(Self);
  fHelpBtn.Parent := fPanel;
  fHelpBtn.OnClick := HelpClickHandler;

  // preview button
  fPreviewBtn := TButton.Create(Self);
  fPreviewBtn.Parent := fPanel;
  fPreviewBtn.OnClick := PreviewClickHandler;

  // label for comment style combo
  fLblCommentStyle := TLabel.Create(Self);
  fLblCommentStyle.Parent := fPanel;
  fLblCommentStyle.Caption := sLblCommentStyle;

  // combo box used to select commenting style
  fCmbCommentStyle := TComboBox.Create(Self);
  fCmbCommentStyle.Parent := fPanel;
  fCmbCommentStyle.Style := csDropDownList;
  fCmbCommentStyle.OnChange := CommentStyleChange;

  // check box used to determine whether to use syntax highlighting
  fChkSyntaxHilite := TCheckBox.Create(Self);
  fChkSyntaxHilite.Parent := fPanel;
  fChkSyntaxHilite.Caption := sChkSyntaxHilite;

  // Set dialog box properties

  // set default button values and states
  SetOnPreview(nil);  // updates state of preview button

  // set dialog options
  Options := [ofPathMustExist, ofEnableIncludeNotify];

  // inhibit default help processing: we provide own help button and handling
  WantDefaultHelpSupport := False;
end;

function TSaveSourceDlg.DoCanClose: Boolean;
  {Called to check if dialog can close. We check for existing file (after adding
  required extension) and inhibit closure if file exists and user doesn't want
  to overwrite.
    @return True if dialog can close and false otherwise.
  }

  // ---------------------------------------------------------------------------
  function QueryOverwrite(const FileName: string): Boolean;
    {Displays a dialog box asking permission to overwrite a file.
      @param FileName [in] Name of file to be overwritten.
      @return True if user agrees that file can be overwritten, false if not.
    }
  resourcestring
    // Text of query displayed in dialog box
    sQueryMsg = '%s already exists.' + EOL + 'Do you want to replace it?';
  begin
    Result := TMessageBox.Confirm(Self, Format(sQueryMsg, [FileName]));
  end;
  // ---------------------------------------------------------------------------

var
  AFileName: string;  // Current file name, adjusted to ensure it has extension
begin
  // Check if user wants to inhibit closure by triggering OnCanClose event
  Result := inherited DoCanClose;
  if not Result then
    Exit;
  // Ask user for permission to overwrite any existing file
  AFileName := AdjustFileName(FileOpenEditedFileName(Self));
  if FileExists(AFileName) and not QueryOverwrite(AFileName) then
    Result := False;
end;

procedure TSaveSourceDlg.DoClose;
  {Tidies up and sets properties from controls when dialog is about to close.
  }
begin
  // Update value of SyntaxHiliting property
  UpdateSyntaxHiliting;
  inherited DoClose;
  // Hide any hint left on screen
  Application.HideHint;
end;

procedure TSaveSourceDlg.DoShow;
  {Sets up dialog just before it is displayed.
  }

  // ---------------------------------------------------------------------------
  function GetDlgCtrlRect(CtrlID: Integer): TRect;
    {Get bounding rectangle of control with given id.
      @return Bounding rectangle.
    }
  begin
    // Get bounds in screen co-ords (controls are children of parent window)
    GetWindowRect(GetDlgItem(GetParent(Handle), CtrlID), Result);
    // Map co-ords to this window
    MapWindowPoints(0, Handle, Result, 2);
  end;
  // ---------------------------------------------------------------------------

var
  FileTypeCmbBounds: TRectEx; // bounds of dlg's filetype combo box
  FileTypeLblBounds: TRect;   // bounds of dlg's filetype label
  ButtonBounds: TRect;        // bounds of one of dlg's buttons
  StaticBounds: TRect;        // bounds of dlg's hidden ctrl (per dlg resource)
  PanelBounds: TRect;         // bounds of panel we add to dlg
  CSIdx: TCommentStyle;       // loops thru comment styles
begin
  // Get bounding rectangle of various dialog box controls
  // bounds of hidden static text control per our custom dialog resource
  StaticBounds := inherited GetStaticRect;
  // bounds of file type combo and associated text (used to align added ctrls)
  FileTypeCmbBounds := GetDlgCtrlRect(cmb1);
  FileTypeLblBounds := GetDlgCtrlRect(stc2);
  // bounds of OK button (used to size buttons we add)
  ButtonBounds := GetDlgCtrlRect(IDOK);

  // Set up TPanel that holds all newly added controls
  GetClientRect(Handle, PanelBounds);       // first size to whole client area
  PanelBounds.Top := StaticBounds.Bottom;   // set top to below hidden ctrl
  fPanel.BoundsRect := PanelBounds;
  fPanel.ParentWindow := Handle;            // make dlg parent of panel

  // Align syntax highlight check box file type combo
  fChkSyntaxHilite.Left := FileTypeCmbBounds.Left;
  fChkSyntaxHilite.Top := 0;
  fChkSyntaxHilite.Width := FileTypeCmbBounds.Width;
  fChkSyntaxHilite.Checked := fUseSyntaxHiliting;

  // Size and align comment style combo box with file type combo box
  fCmbCommentStyle.Left := FileTypeCmbBounds.Left;
  fCmbCommentStyle.Top := fChkSyntaxHilite.Top + fChkSyntaxHilite.Height + 6;
  fCmbCommentStyle.Width := FileTypeCmbBounds.Width;
  // Set up combo box text (can't be done in constructor since a parent window
  // is required and host panel doesn't have one at that point)
  if fCmbCommentStyle.Items.Count = 0 then
  begin
    // Populate comment style combo
    for CSIdx := Low(TCommentStyle) to High(TCommentStyle) do
      fCmbCommentStyle.Items.AddObject(
        TSourceComments.CommentStyleDesc(CSIdx), TObject(CSIdx)
      );
  end;
  UpdateCommentStyle;

  // Align comment style label within group box
  fLblCommentStyle.Left := FileTypeLblBounds.Left;
  fLblCommentStyle.Top := fCmbCommentStyle.Top +
    (fCmbCommentStyle.Height - fLblCommentStyle.Height) div 2;

  // Size preview button and align under above buttons
  fPreviewBtn.BoundsRect := ButtonBounds;
  fPreviewBtn.Top := 0;
  fPreviewBtn.Caption := sBtnPreview;

  // Size help button, enable/disable as required & align under preview buttons
  fHelpBtn.BoundsRect := ButtonBounds;
  fHelpBtn.Top := fPreviewBtn.Top + fPreviewBtn.Height + 6;
  fHelpBtn.Caption := sBtnHelp;
  fHelpBtn.Enabled := (HelpKeyword <> '');

  // Call this to ensure we trigger type change event for default file type
  DoTypeChange;

  inherited;
end;

procedure TSaveSourceDlg.DoTypeChange;
  {Notifies when a different file type is selected in file type combo box.
  Checks if syntax highlighting supported for selected file type.
  }
var
  CanHilite: Boolean; // flag true if syntax highlighting supported
begin
  // Assume highlighting not supported
  CanHilite := False;
  // Trigger event where user specifies if highlighting supported
  if Assigned(fOnHiliteQuery) then
    fOnHiliteQuery(Self, SelectedExt, CanHilite);
  // Enable / disable highlighting check box as required
  fChkSyntaxHilite.Enabled := CanHilite;
  fSelectedFilterIdx := inherited FilterIndex;
  inherited;
end;

function TSaveSourceDlg.Execute: Boolean;
  {Displays dialog box. Sets required dialog box template if new style dialogs
  being used. Adjusts any extension-less file name to have extension of selected
  file type.
    @return True if user OKs and false if cancels.
  }
begin
  // Set up template for customisation
  if NewStyleControls and not (ofOldStyleDialog in Options) then
    Template := cTemplateName
  else
    Template := nil;
  // Display dialog box
  Result := inherited Execute;
  if Result then
    // Adjust file name, adding any missing extension
    FileName := AdjustFileName(FileName);
end;

function TSaveSourceDlg.GetFilterIndex: Integer;
  {Gets index of selected filter.
    @return Selected filter index.
  }
begin
  if Handle <> 0 then
    // dialog box is open: use inherited FilterIndex property
    Result := inherited FilterIndex
  else
    // dialog box is closed: use recorded index to overcome apparent bug
    Result := fSelectedFilterIdx;
end;

function TSaveSourceDlg.GetSelectedExt: string;
  {Read accessor for SelectedExt property. Extracts extension for selected file
  type from Filter property.
    @return Selected extension with leading '.'.
  }
begin
  Result := FilterIndexToExt(Self);
end;

procedure TSaveSourceDlg.HelpClickHandler(Sender: TObject);
  {Handles click on help button. Calls help with required keyword.
    @param Sender [in] Not used.
  }
begin
  DisplayHelp;
end;

procedure TSaveSourceDlg.PreviewClickHandler(Sender: TObject);
  {Handles click on preview button. Updates properties then triggers OnPreview
  event.
    @param Sender [in] Not used.
  }
begin
  UpdateSyntaxHiliting;
  if Assigned(fOnPreview) then
    fOnPreview(Self);
end;

procedure TSaveSourceDlg.SetFilterIndex(const Value: Integer);
  {Records index of selected file filter.
    @param Value [in] New value of selected file filter.
  }
begin
  // record index in inherited property
  inherited FilterIndex := Value;
  // also record filter in own field: used to overcome apparent bug
  fSelectedFilterIdx := Value;
end;

procedure TSaveSourceDlg.SetOnPreview(const Value: TNotifyEvent);
  {Write accessor for OnPreview event. Enables / disables preview button
  depending on if event handler assigned.
    @param Value [in] Required event handler.
  }
begin
  fOnPreview := Value;
  fPreviewBtn.Enabled := Assigned(Value);
end;

procedure TSaveSourceDlg.UpdateCommentStyle;
  {Selects appropriate item in comment style combo box per current comment style
  property.
  }
var
  Idx: Integer; // loops thru combo box items
begin
  for Idx := 0 to Pred(fCmbCommentStyle.Items.Count) do
  begin
    // comment style stored in Objects[] property
    if TCommentStyle(fCmbCommentStyle.Items.Objects[Idx]) = fCommentStyle then
      fCmbCommentStyle.ItemIndex := Idx;
  end;
end;

procedure TSaveSourceDlg.UpdateSyntaxHiliting;
  {Updates value of UseSyntaxHiliting property per state of dialog box controls.
  }
begin
  fUseSyntaxHiliting := fChkSyntaxHilite.Checked;
end;

end.