main.pas

FlexGraphics是一套创建矢量图形的VCL组件

end;

procedure TEditMainForm.FormDockDrop(Sender: TObject);
begin
  DisableAlign;
  try
    sbrMain.Top := Height;
    sptColors.Left := Width;
    panColors.Left := Width;
  finally
    EnableAlign;
  end;
end;

function TEditMainForm.CreateToolWindow(ToolForm: TCustomForm;
  DockTo: TWinControl; DockAlign: TAlign = alNone): TToolContainer;
begin
 if (DockAlign = alClient) and (DockTo is TPanel) and
    (DockTo.ControlCount > 0) and (DockTo.Controls[0] is TToolContainer) then
   DockTo := TToolContainer(DockTo.Controls[0]);
 if Assigned(DockTo) and (DockTo is TToolContainer) then begin
  // Dock to existen tool container
  Result := TToolContainer(DockTo);
  Result.InsertTool(ToolForm);
  Result.ActivePageForm := ToolForm;
  exit;
 end;
 Result := TToolContainer.Create(Application);
 with Result do begin
  InitDockSites(FDockSites);
  OnNeedClose := ToolWinNeedClose;
  OnPopupChange := ToolWinPopupChange;
  InsertTool(ToolForm);
  Show;
 end;
 if Assigned(DockTo) and (DockTo is TPanel) then
   Result.ManualDock(DockTo, Nil, DockAlign);
end;

procedure TEditMainForm.ToolWinNeedClose(Sender: TObject);
begin
 if Sender is TToolContainer then TToolContainer(Sender).Close;
end;

procedure TEditMainForm.ToolWinPopupChange(Sender: TObject);
begin
 if not (csDestroying in ComponentState) then CheckTools;
end;

procedure TEditMainForm.acDockerExecute(Sender: TObject);
var ToolForm: TCustomForm;
    Container: TToolContainer;
begin
 if Sender = acDockerInspector then ToolForm := fmInspector else
 if Sender = acDockerLibrary   then ToolForm := fmLibrary else
 if Sender = acDockerUserData  then ToolForm := fmUserData else
 if Sender = acDockerLayers    then ToolForm := fmLayers else exit;
 Container := FindToolParentContainer(ToolForm);
 if not Assigned(Container) then
  CreateToolWindow(ToolForm, DockSites.RightDockPanel, alClient)
 else
  Container.RemoveTool(ToolForm);
 CheckTools;
end;

procedure TEditMainForm.acDockerPaletteExecute(Sender: TObject);
var Enabled: boolean;
begin
 Enabled := not acDockerPalette.Checked; // invert
 if panColors.Visible = Enabled then exit;
 if Enabled then begin
  // Show palette
  panColors.Visible := true;
  panColors.Left := Self.ClientWidth;
  sptColors.Visible := true;
  sptColors.Left := panColors.Left;
 end else begin
  // Hide palette
  panColors.Visible := false;
  sptColors.Visible := false;
 end;
 CheckTools;
end;

procedure TEditMainForm.acLayerNewExecute(Sender: TObject);
var Layer: TFlexLayer;
begin
 if not Assigned(ActiveFlex) then exit;
 with ActiveFlex do begin
  Layer := Layers.New;
  ActiveLayer := Layer;
 end;
 fmInspector.Control := Layer;
end;

procedure TEditMainForm.acLayerDeleteExecute(Sender: TObject);
begin
 if not Assigned(ActiveFlex) then exit;
 with ActiveFlex do
  if MessageDlg(Format(SDeleteLayer, [ActiveLayer.Name]),
    mtConfirmation, [mbYes, mbNo], 0) = mrYes then
   Layers.Remove(ActiveLayer);
end;

procedure TEditMainForm.acSchemeNewExecute(Sender: TObject);
var Scheme: TFlexScheme;
begin
 if not Assigned(ActiveFlex) then exit;
 with ActiveFlex do begin
  Scheme := TFlexScheme.Create(Schemes.Owner, Schemes, Nil); //Schemes.New;
  ActiveScheme := Scheme;
 end;
 fmInspector.Control := Scheme;
end;

procedure TEditMainForm.acSchemeDeleteExecute(Sender: TObject);
begin
 if not Assigned(ActiveFlex) then exit;
 with ActiveFlex do
  if MessageDlg(Format(SDeleteScheme, [ActiveScheme.Name]),
    mtConfirmation, [mbYes, mbNo], 0) = mrYes then
   Schemes.Remove(ActiveScheme);
end;

procedure TEditMainForm.acFileNewExecute(Sender: TObject);
begin
 CreateDocument('');
end;
{
function TEditMainForm.GetActiveFlex: TFlexPanel;
var Child: TCustomForm;
begin
 Child := ActiveMDIChild;
 if Assigned(Child) and (Child is TFlexChildForm)
  then Result := TFlexChildForm(Child).Flex
  else Result := Nil;
end;
}
procedure TEditMainForm.ChildChange(Sender: TObject);
var Flex: TFlexPanel;
begin
 if Assigned(ActiveMDIChild)
  then Flex := TFlexChildForm(ActiveMDIChild).Flex
  else Flex := Nil;
 if Assigned(Flex) and (csDestroying in Flex.ComponentState) then Flex := Nil;
 if Flex <> FActiveFlex then begin
  FActiveFlex := Flex;
  UpdateToolWins(Flex);
  UpdateLayers(Flex);
  UpdateSchemes(Flex);
  //SetCurrentOptions(Flex);
  CheckTools;
  {$IFDEF DEBUG_HISTORY}
  if Assigned(fmHistoryDebug) then fmHistoryDebug.Flex := Flex;
  {$ENDIF}
 end;
end;

procedure TEditMainForm.HistoryChange(Sender: TObject);
begin
 if Assigned(FActiveFlex) and (Sender = FActiveFlex.History) then begin
  CheckTools;
  {$IFDEF DEBUG_HISTORY}
  if Assigned(fmHistoryDebug) then fmHistoryDebug.HistoryChange(Sender);
  {$ENDIF}
 end;
end;

procedure TEditMainForm.UpdateToolWins(Flex: TFlexPanel);
begin
 if Assigned(fmInspector) then fmInspector.ActiveFlex := Flex;
 if Assigned(fmLibrary) then fmLibrary.ActiveFlex := Flex;
 if Assigned(fmUserData) then fmUserData.ActiveFlex := Flex;
 if Assigned(fmLayers) then fmLayers.ActiveFlex := Flex;
end;

procedure TEditMainForm.ControlPropChanged(Sender: TObject; Prop: TCustomProp);
var Panel: TFlexPanel;
begin
 if FIsFileLoading then exit;
 if Sender = fmInspector.Control then fmInspector.UpdateProps(Prop);
 if (Sender = fmUserData.SelControl) and Assigned(Prop) and
    (Prop = TFlexControl(Sender).UserData) then fmUserData.UpdateData;
 if Assigned(Sender) and (Sender is TFlexLayer) then begin
  if Assigned(fmLayers) then fmLayers.UpdateData(TFlexLayer(Sender));
  if Assigned(fmInspector) and Assigned(fmInspector.Control) then
   fmInspector.UpdateProps(fmInspector.Control.LayerProp);
 end;
 Panel := TFlexControl(Sender).Owner;
 if not (Panel.ToolMode in
   [ ftmResizing, ftmMoving, ftmSelecting, ftmZoom, ftmZooming,
     ftmMove, ftmMoving, ftmResize, ftmResizing, ftmCreating,
     ftmPointSelecting, ftmCurveMoving, ftmPan, ftmPanning ]) or
   ((Panel = ActiveFlex) and (Panel.Modified <> FActiveFlexModified)) then
  CheckTools;
end;

procedure TEditMainForm.ActiveLibChange(Sender: TObject);
begin
 CheckTools;
end;

function TEditMainForm.CreateDocument(const DocName: string): TFlexChildForm;
begin
 Result := TFlexChildForm.Create(Application);
 with Result do begin
  Flex.InDesign := true;
  Flex.History.DisableRecording;
  try
   Flex.OnNotify := ControlNotify;
   Flex.OnPropChanged := ControlPropChanged;
   Flex.OnEndSelectionUpdate := FlexEndSelUpdate;
   Flex.OnProgress := FlexProgress;
   Flex.OnToolMode := CheckToolButtons;
   Flex.History.OnChange := HistoryChange;
   Flex.PopupMenu := pmControl;
   OnActiveChange := ChildChange;
   if DocName = '' then begin
    Filename := 'Document' + IntToStr(Self.MDIChildCount+1);
    Flex.DocWidth := EditOptions.DocWidth;
    Flex.DocHeight := EditOptions.DocHeight;
    Flex.Modified := False;
    SetCurrentOptions(Flex);
    FormStyle := fsMDIChild;
   end else begin
    Caption := DocName;
   end;
   ChildChange(Result);
  finally
   Flex.History.EnableRecording;
  end;
 end;
end;

procedure TEditMainForm.SetCurrentOptions(Flex: TFlexPanel;
  const Edited: TOptionEditPages);
begin
 if not Assigned(Flex) then exit;
 with EditOptions do begin
  if opDocument in Edited then begin
   //Flex.DocWidth := DocWidth;
   //Flex.DocHeight := DocHeight;
   Flex.AutoNameNumbs := DocAutoNameNumbs;
  end;
  if opGrid in Edited then begin
   Flex.ShowGrid := ShowGrid;
   Flex.SnapToGrid := SnapToGrid;
   Flex.SnapStyle := SnapStyle;
   Flex.ShowPixGrid := ShowPixGrid;
   Flex.GridStyle := GridStyle;
   Flex.GridColor := GridColor;
   Flex.GridPixColor := GridPixColor;
   Flex.GridHorizSize := GridHSize;
   Flex.GridVertSize := GridVSize;
   Flex.GridControl.HOffset := GridHOffset;
   Flex.GridControl.VOffset := GridVOffset;
   Flex.Refresh;
  end;
  if opConnectors in Edited then begin
   // Flex.ConnectorsMinGap := ConnectorsMinGap;
  end;
 end;
end;

procedure TEditMainForm.cbActiveLayerChange(Sender: TObject);
begin
 if Assigned(ActiveFlex) then with ActiveFlex do begin
  ActiveLayer :=
    TFlexLayer(cbActiveLayer.Items.Objects[cbActiveLayer.ItemIndex]);
  UnselectAll;
  fmInspector.Control := ActiveLayer;
 end;
end;

procedure TEditMainForm.cbActiveSchemeChange(Sender: TObject);
begin
 if Assigned(ActiveFlex) then begin
  ActiveFlex.ActiveScheme :=
   TFlexScheme(cbActiveScheme.Items.Objects[cbActiveScheme.ItemIndex]);
  fmInspector.Control := ActiveFlex.ActiveScheme;
 end;
end;

function TEditMainForm.SaveChanges(ChildForm: TFlexChildForm;
  AskName: boolean = true): boolean;
var SaveName: string;
begin
 SaveName := ChildForm.Filename;
 if AskName or ChildForm.NewDocument then begin
  sd_Main.FileName := SaveName;
  Result := sd_Main.Execute;
  if not Result then exit;
  SaveName := sd_Main.FileName;
 end;
 BeginFilerProcess;
 try
  Result := ChildForm.Flex.SaveToFile(SaveName);
  ChildForm.Filename := SaveName;
 finally
  EndFilerProcess;
 end;
 CheckTools;
end;

procedure TEditMainForm.acFileSaveExecute(Sender: TObject);
begin
 SaveChanges(TFlexChildForm(ActiveMDIChild), false);
end;

procedure TEditMainForm.acFileSaveAsExecute(Sender: TObject);
begin
 SaveChanges(TFlexChildForm(ActiveMDIChild));
end;

function TEditMainForm.ExecuteImportExportDialog(
  Kind: TFlexFileSupportKind): integer;
var
  Dialog: TOpenDialog;
  i: integer;
  Extensions: TStringList;
  FilterStr, Ext: string;
begin
  Result := -1;
  case Kind of
    skImport: Dialog := od_Import;
    skExport: Dialog := sd_Export;
    else
      Exit;
  end;
  Extensions := TStringList.Create;
  try
    // Include all extensions that support necessary Kind
    for i:=0 to RegisteredFlexFileFormats.Count-1 do
      with RegisteredFlexFileFormats[i] do
        if Kind in Kinds then begin
          Extensions.AddObject(
            Format('%s (*.%s)|*.%1:s', [Description, Extension]),
            pointer(i));
        end;
    Extensions.Sort;
    // Add 'ALL' item
    if (Kind = skImport) and (Extensions.Count > 1) then begin
      FilterStr := '';
      for i:=0 to Extensions.Count-1 do begin
        Ext := Format('*.%s', [
          RegisteredFlexFileFormats[integer(Extensions.Objects[i])].Extension]);
        if i = 0 then
          FilterStr := Ext
        else
          FilterStr := Format('%s;%s', [FilterStr, Ext]);
      end;
      Extensions.InsertObject(0,
        Format('All (%s)|%0:s', [FilterStr]), pointer(-1));
    end;
    // Make filter string for dialog
    for i:=0 to Extensions.Count-1 do
      if i = 0 then
        FilterStr := Extensions[i]
      else
        FilterStr := Format('%s|%s', [FilterStr, Extensions[i]]);
    Dialog.Filter := FilterStr;
    // Execute dialog
    if Dialog.Execute then begin
      Result := integer(Extensions.Objects[Dialog.FilterIndex - 1]);
      if Result < 0 then begin
        // Define filter index by extension
        Ext := ExtractFileExt(Dialog.FileName);
        if (Length(Ext) > 1) and (Ext[1] = '.') then Delete(Ext, 1, 1);
        for i:=0 to RegisteredFlexFileFormats.Count-1 do
          with RegisteredFlexFileFormats[i] do
            if (Kind in Kinds) and (CompareText(Extension, Ext) = 0) then begin
              Result := i;
              Break;
            end;
      end;
    end;
  finally
    Extensions.Free;
  end;
end;

procedure TEditMainForm.acFileImportExecute(Sender: TObject);
var Child: TFlexChildForm;
    Index: integer;
    FxdFilename: string;
    TempFlex: TFlexPanel;
begin
 Index := ExecuteImportExportDialog(skImport);
 if Index < 0 then exit;
 // Create form for document
 FxdFilename := ChangeFileExt(od_Import.Filename, '.fxd');
 Child := CreateDocument('');
 try
  if not Assigned(Child) then exit;
  Child.Caption := ExtractFilename(FxdFilename);
  BeginFilerProcess;
  try
   FIsFileLoading := true;
   TempFlex := TFlexPanel.Create(Nil);
   try
    RegisteredFlexFileFormats.ImportFromFile(Index, TempFlex,
      od_Import.FileName);
    Child.Flex.Assign(TempFlex);
   finally
    TempFlex.Free;
   end;
   Child.Filename := FxdFilename;
   Child.FormStyle := fsMDIChild;
   // Update tools
   SetCurrentOptions(Child.Flex, AllOptions);
   fmUserData.UpdateData;
   UpdateLayers(Child.Flex);
   UpdateSchemes(Child.Flex);
   fmLibrary.FlexSelectionChange;
   fmInspector.UpdateData;
   fmInspector.UpdateProps(Nil);
  finally
   FIsFileLoading := false;
   EndFilerProcess;
  end;
  sd_Main.FileName := FxdFilename;
 except
  Child.Free;
  raise;
 end;
 CheckTools;
end;

procedure TEditMainForm.acFileExportExecute(Sender: TObject);
var Flex: TFlexPanel;
    Index: integer;
begin
 Flex := ActiveFlex;
 if not Assigned(Flex) then exit;
 Index := ExecuteImportExportDialog(skExport);
 if Index >= 0 then
  RegisteredFlexFileFormats.ExportToFile(Index, Flex, sd_Export.FileName);
end;

procedure TEditMainForm.acFileOpenExecute(Sender: TObject);
var Child: TFlexChildForm;