main.pas

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

   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 := od_Main.Filename;
 except
  Child.Free;
  raise;
 end;
 CheckTools;
end;

procedure TEditMainForm.acFilePrintExecute(Sender: TObject);
begin
 if not Assigned(ActiveFlex) or not pd_Main.Execute then exit;
 ActiveFlex.Print(Printer, True, pd_Main.PrintRange = prSelection);
end;

procedure TEditMainForm.ViewOptionsExecute(Page: TOptionEditPage = opDocument);
var fmOptions: TfmOptions;
begin
 fmOptions := TfmOptions.Create(Application);
 try
  fmOptions.EditOptions := EditOptions;
  fmOptions.Page := Page;
  if fmOptions.ShowModal = mrOk then begin
   Move(fmOptions.EditOptions, EditOptions, SizeOf(EditOptions));
   UpdateAllOptions(fmOptions.Edited);
  end;
 finally
  fmOptions.Free;
 end;
end;

procedure TEditMainForm.acViewOptionsExecute(Sender: TObject);
begin
 ViewOptionsExecute;
end;

procedure TEditMainForm.acFilePropertiesExecute(Sender: TObject);
var Flex: TFlexPanel;
begin
 Flex := ActiveFlex;
 if not Assigned(Flex) then exit;
 fmDocProps := TfmDocProps.Create(Application);
 with fmDocProps do
 try
  Tag := integer(Flex);
  if ShowModal = mrOk then Flex.Refresh;
 finally
  fmDocProps.Free;
 end;
end;

procedure TEditMainForm.UpdateLayers(Flex: TFlexPanel);
var StrList: TStringList;
    i: integer;
begin
 if not Assigned(Flex) then exit;
 StrList := Nil;
 cbActiveLayer.Items.BeginUpdate;
 try
  StrList := TStringList.Create;
  for i:=0 to Flex.Layers.Count-1 do
   StrList.AddObject(Flex.Layers[i].Name, Flex.Layers[i]);
  StrList.Sort;
  cbActiveLayer.ItemIndex := -1;
  cbActiveLayer.Items.Assign(StrList);
  cbActiveLayer.ItemIndex := StrList.IndexOfObject(Flex.ActiveLayer);
  cbActiveLayer.Refresh;
 finally
  cbActiveLayer.Items.EndUpdate;
  StrList.Free;
 end;
 fmLayers.UpdateData;
end;

procedure TEditMainForm.UpdateSchemes(Flex: TFlexPanel);
var StrList: TStringList;
    i: integer;
begin
 if not Assigned(Flex) then exit;
 StrList := Nil;
 cbActiveScheme.Items.BeginUpdate;
 try
  StrList := TStringList.Create;
  for i:=0 to Flex.Schemes.Count-1 do
   StrList.AddObject(Flex.Schemes[i].Name, Flex.Schemes[i]);
  StrList.Sort;
  cbActiveScheme.Items.Assign(StrList);
  cbActiveScheme.ItemIndex := StrList.IndexOfObject(Flex.ActiveScheme);
 finally
  cbActiveScheme.Items.EndUpdate;
  StrList.Free;
 end;
end;

procedure TEditMainForm.UpdateAllOptions(const Edited: TOptionEditPages);
var i: integer;
begin
 for i:=0 to MDIChildCount-1 do with TFlexChildForm(MDIChildren[i]) do
  SetCurrentOptions(Flex, Edited);
end;

procedure TEditMainForm.CheckUpdates(Flex: TFlexPanel);
begin
 if Flex.SelectionUpdateCounter = 0 then begin
  if FInspDataNeedUpdate then begin
   fmInspector.UpdateData;
   FInspDataNeedUpdate := False;
  end;
  if FInspPropsNeedUpdate then begin
   fmInspector.UpdateProps(Nil);
   FInspDataNeedUpdate := False;
  end;
 end;
end;

procedure TEditMainForm.FlexEndSelUpdate(Sender: TObject);
begin
 if Sender = ActiveFlex then CheckUpdates(TFlexPanel(Sender));
end;

procedure TEditMainForm.ControlNotify(Sender: TObject;
  Control: TFlexControl; Notify: TFlexNotify);
var Flex: TFlexPanel;
    NeedUpdate: boolean;
begin
 if FIsFileLoading or (csDestroying in ComponentState) or
    not Assigned(Sender) or not (Sender is TFlexPanel) then exit;
 Flex := TFlexPanel(Sender);
 if Flex <> ActiveFlex then exit;
 if Notify in [ fnName, fnCreated, fnDestroyed, fnOrder ] then begin
  {if Flex.SelectionUpdateCounter = 0 then fmInspector.UpdateData; }
  FInspDataNeedUpdate := True;
 end;
 NeedUpdate := false;
 case Notify of
  fnDestroyed:
    begin
     if Control = fmInspector.Control then fmInspector.Control := Nil;
     fmUserData.UpdateData;
    end;
  fnName:
    if Assigned(Control) then
     if Control is TFlexLayer then UpdateLayers(Flex) else
     if Control is TFlexScheme then UpdateSchemes(Flex);
  fnSelect:
    begin
     if Flex.SelectedCount = 1
      then fmInspector.Control := Flex.Selected[0]
      else fmInspector.Control := Nil;
     fmLibrary.FlexSelectionChange;
     fmUserData.UpdateData;
     if Flex.HandleAllocated then Windows.SetFocus(Flex.Handle);
     sbrMain.SimpleText := 'Selected: '+IntToStr(Flex.SelectedCount);
     NeedUpdate := true;
    end;
  fnLayers:
    UpdateLayers(Flex);
  fnSchemes:
    begin
     UpdateSchemes(Flex);
     FInspDataNeedUpdate := True;
     FInspPropsNeedUpdate := True;
   {  fmInspector.UpdateData;
     fmInspector.UpdateProps(Nil); }
    end;
  fnRect:
    exit;
  fnScale:
    begin
     CheckTools;
     exit;
    end;
 end;
 if NeedUpdate or not (Flex.ToolMode in
   [ ftmResizing, ftmMoving, ftmSelecting, ftmZoom, ftmZooming,
     ftmMove, ftmMoving, ftmResize, ftmResizing, ftmCreating,
     {ftmPointSelecting, }ftmCurveMoving, ftmPan, ftmPanning ]) then begin
  CheckUpdates(Flex);
  CheckTools;
 end;
end;

procedure TEditMainForm.BeginFilerProcess;
begin
 Screen.Cursor := crHourGlass;
 sbrMain.SimplePanel := False;
end;

procedure TEditMainForm.EndFilerProcess;
begin
 Screen.Cursor := crDefault;
 sbrMain.SimplePanel := True;
end;

function TEditMainForm.GetInFilerProcess: boolean;
begin
 Result := not sbrMain.SimplePanel;
end;

procedure TEditMainForm.FlexProgress(Sender: TObject; Progress: integer;
  Process: TFlexFilerProcess);
begin
 if not InFilerProcess then exit;
 FFilerProgress := Progress;
 sbrMain.Refresh;
end;

procedure TEditMainForm.sbrMainDrawPanel(StatusBar: TStatusBar;
  Panel: TStatusPanel; const Rect: TRect);
var R: TRect;
begin
 if Panel <> sbrMain.Panels[0] then exit;
 R := Rect;
 InflateRect(R, -1, -1);
 R.Right := R.Left + Round(FFilerProgress / 100 * (R.Right - R.Left)); 
 with sbrMain.Canvas do begin
  Brush.Style := bsSolid;
  Brush.Color := clNavy;
  FillRect(R);
 end;
end;

procedure TEditMainForm.acArrangeForwardOneExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.ForwardOne;
end;

procedure TEditMainForm.acArrangeBackOneExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.BackOne;
end;

procedure TEditMainForm.acArrangeToFrontExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.ToFront;
end;

procedure TEditMainForm.acArrangeToBackExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.ToBack;
end;

procedure TEditMainForm.acArrangeGroupExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.Group;
end;

procedure TEditMainForm.acArrangeUngroupExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.Ungroup;
end;

procedure TEditMainForm.acEditDeleteExecute(Sender: TObject);
var Flex: TFlexPanel;
begin
 Flex := ActiveFlex;
 if not Assigned(Flex) or not Flex.Focused then exit;
 if (Flex.ToolMode = ftmPointEdit) and (Flex.EditPointSelectedTotal > 0) then begin
  if Flex.EditPointControl.PointCount - Flex.EditPointSelectedTotal > 2 then
   Flex.DeleteSelectedPoints;
 end else
  Flex.DeleteSelected;
end;

procedure TEditMainForm.acEditCopyExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.CopyToClipboard;
end;

procedure TEditMainForm.acEditCutExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.CutToClipboard;
end;

procedure TEditMainForm.acEditPasteExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then ActiveFlex.PasteFromClipboard;
end;

procedure TEditMainForm.acEditPasteUpdate(Sender: TObject);
begin
 acEditPaste.Enabled :=
   Assigned(ActiveFlex) and ActiveFlex.PasteAvailable; //Clipboard.HasFormat(CF_FLEXDOC);
end;

procedure TEditMainForm.acAlignExecute(Sender: TObject);
var Align: TFlexAlign;
begin
 if Sender = acAlignLeft     then Align := faLeft else
 if Sender = acAlignHCenter  then Align := faHCenter else
 if Sender = acAlignRight    then Align := faRight else
 if Sender = acAlignTop      then Align := faTop else
 if Sender = acAlignVCenter  then Align := faVCenter else
 if Sender = acAlignBottom   then Align := faBottom else
 if Sender = acAlignCenter   then Align := faCenter
                             else Align := faLeft;
 if Assigned(ActiveFlex) then ActiveFlex.AlignSelected(Align);
end;

procedure TEditMainForm.acFilePreviewExecute(Sender: TObject);
var WasModified: boolean;
begin
 fmPreview := TfmPreview.Create(Nil);
 try
  BeginFilerProcess;
  try
   WasModified := ActiveFlex.Modified;
   fmPreview.Flex.OnProgress := FlexProgress;
   fmPreview.Flex.Assign(ActiveFlex);
   fmPreview.Flex.OnProgress := Nil;
   ActiveFlex.Modified := WasModified;
  finally
   EndFilerProcess;
  end;
  CheckTools;
  fmPreview.Caption := fmPreview.Caption + ' ['+ActiveMDIChild.Caption+']';
  fmPreview.ShowModal;
 finally
  fmPreview.Free;
  fmPreview := Nil;
  CheckTools;
 end;
end;

procedure TEditMainForm.acLibItemAddExecute(Sender: TObject);
begin
 if Assigned(fmLibrary) then fmLibrary.acLibAddItem.Execute;
end;

procedure TEditMainForm.acZoomInExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then with ActiveFlex do Zoom(Scale * 2, Nil);
end;

procedure TEditMainForm.acZoomOutExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then with ActiveFlex do Zoom(Scale div 2, Nil);
end;

procedure TEditMainForm.acZoomActualExecute(Sender: TObject);
begin
 if Assigned(ActiveFlex) then with ActiveFlex do Zoom(100, Nil);
end;

function TEditMainForm.GetToolScale: integer;
var i, Len: integer;
    s: string;
begin
 Result := 100;
 if not Assigned(ActiveFlex) then exit;
 s := cbZoom.Text;
 Len := Length(s);
 for i:=1 to Len+1 do
  if (i > Len) or (s[i] < '0') or (s[i] > '9') then begin
   Result := StrToIntDef(copy(s, 1, i-1), -1);
   if Result < 0 then Result := ActiveFlex.Scale;
   break;
  end;
end;

procedure TEditMainForm.cbZoomExit(Sender: TObject);
var NewScale: integer;
begin
 NewScale := GetToolScale;
 if Assigned(ActiveFlex) then with ActiveFlex do
  if NewScale <> Scale then Zoom(NewScale, Nil);
end;

procedure TEditMainForm.cbZoomClick(Sender: TObject);
var NewScale: integer;
begin
 NewScale := GetToolScale;
 if Assigned(ActiveFlex) then with ActiveFlex do
  if NewScale <> Scale then Zoom(NewScale, Nil);
end;

procedure TEditMainForm.cbZoomKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
 if Key = VK_RETURN then
  cbZoomClick(cbZoom)
 else
 if Key = VK_ESCAPE then
  CheckTools;
end;

procedure TEditMainForm.acEditCloneExecute(Sender: TObject);
var Shift: TPoint;
    SelList: TList;
    i: integer;
begin
 if not Assigned(ActiveFlex) then exit;
 SelList := Nil;
 with ActiveFlex do
 try
  Shift := Point(EditOptions.ShiftX, EditOptions.ShiftY);
  if EditOptions.DupRandom then begin
   Randomize;
   Shift.X := Round(Random * 2*Shift.X) - Shift.X;
   Shift.Y := Round(Random * 2*Shift.Y) - Shift.Y;
   SelList := TList.Create;
   for i:=0 to SelectedCount-1 do SelList.Add(Selected[i]);
  end;
  CloneSelected(Shift.X, Shift.Y);
  if Assigned(SelList) then begin
   BeginSelectionUpdate;
   try
    UnselectAll;
    for i:=0 to SelList.Count-1 do Select(TFlexControl(SelList[i]));
   finally
    EndSelectionUpdate;
   end;
  end;
 finally
  SelList.Free;
 end;
end;

procedure TEditMainForm.acEditDuplicateExecute(Sender: TObject);
var Shift: TPoint;
    SelList: TList;
    i: integer;
begin
 if not Assigned(ActiveFlex) then exit;
 SelList := Nil;
 with ActiveFlex do
 try
  Shift := Point(EditOptions.ShiftX, EditOptions.ShiftY);
  if EditOptions.DupRandom then begin