开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
am2000designer.pas
资源名称：am2000.zip　[点击查看]
上传用户：powellwoo
上传日期：2007-01-07
资源大小：109k
文件大小：54k
源码类别：

Delphi控件源码

开发平台：

C++ Builder

am2000designer.pas：源码内容
  2. {*******************************************************}
  3. {                                                       }
  4. {       AnimatedMenus/2000                              }
  5. {       T_AM2000_MenuDesigner Component Unit            }
  6. {                                                       }
  7. {       Copyright (c) 1997-99 AnimatedMenus.com         }
  8. {       All rights reserved.                            }
  9. {                                                       }
  10. {*******************************************************}
  13. unit am2000designer;
  15. {$I am2000.inc}
  17. interface
  19. uses
  20.   Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  21.   StdCtrls, CommCtrl, ComCtrls, ExtCtrls,
  22.   Buttons, Menus, Registry, LibHelp, DsgnIntf,
  23.   {$IFDEF Delphi3OrHigher} ExtDlgs, {$ENDIF}
  24.   {$IFDEF Delphi4OrHigher} ImgList, {$ENDIF}
  25.   {$IFDEF Delphi5OrHigher} Contnrs, {$ENDIF}
  26.   am2000menuitem, am2000popupmenu, am2000mainmenu, am2000cache, am2000,
  27.   am2000utils;
  29. type
  31.   T_AM2000_TreeView4 = class;
  33. {$IFNDEF Delphi4OrHigher}
  34.   TCustomDrawTarget = (dtControl, dtItem, dtSubItem);
  35.   TCustomDrawStage = (cdPrePaint, cdPostPaint, cdPreErase, cdPostErase);
  36.   TCustomDrawState = set of (cdsSelected, cdsGrayed, cdsDisabled, cdsChecked,
  37.     cdsFocused, cdsDefault, cdsHot, cdsMarked, cdsIndeterminate);
  39.   TTVCustomDrawItemEvent = procedure(Sender: TCustomTreeView; Node: TTreeNode;
  40.     State: TCustomDrawState; var DefaultDraw: Boolean) of object;
  41. {$ENDIF}
  44.   // menu designer
  45.   T_AM2000_MenuDesigner = class(TPropertyEditor)
  46.   public
  47.     function GetValue: string; override;
  48.     function GetAttributes: TPropertyAttributes; override;
  49.     procedure Edit; override;
  51.   end;
  53.   // component editor
  54.   T_AM2000_ComponentEditor = class(TComponentEditor)
  55.   public
  56.     function GetVerbCount: Integer; override;
  57.     function GetVerb(Index: Integer): String; override;
  58.     procedure ExecuteVerb(Index: Integer); override;
  59.     procedure Edit; override;
  61.   end;
  63.   // dialog for menu designer
  64.   T_AM2000_MenuDesignerDlg = class(TForm)
  65.     Panel1: TPanel;
  66.     ButtonNewMenuItem: TSpeedButton;
  67.     ButtonNewSubMenu: TSpeedButton;
  68.     Bevel1: TBevel;
  69.     ButtonDelete: TSpeedButton;
  70.     Bevel2: TBevel;
  71.     ButtonLevelUp: TSpeedButton;
  72.     ButtonMoveUp: TSpeedButton;
  73.     ButtonMoveDown: TSpeedButton;
  74.     ButtonLevelDown: TSpeedButton;
  75.     PopupMenu20001: TPopupMenu2000;
  76.     DefaultBitmaps1: TMenuItem2000;
  77.     N2: TMenuItem2000;
  78.     None1: TMenuItem2000;
  79.     ButtonArray1: TMenuItem2000;
  80.     OpenDialog1: TOpenDialog;
  81.     SaveDialog1: TSaveDialog;
  82.     NewItem1: TMenuItem2000;
  83.     NewSubmenuItem1: TMenuItem2000;
  84.     MenuItem3: TMenuItem2000;
  85.     ImageListBitmaps1: TMenuItem2000;
  86.     None2: TMenuItem2000;
  87.     ButtonArray2: TMenuItem2000;
  88.     DefaultBitmapsMenu: TPopupMenu2000;
  89.     ImageListMenu: TPopupMenu2000;
  90.     LoadBitmapFromFile1: TMenuItem2000;
  91.     SaveBitmapToFile1: TMenuItem2000;
  92.     AM2000MenuDesigner4: TMenuItem2000;
  93.     ExpandAll1: TMenuItem2000;
  94.     CollapseAll1: TMenuItem2000;
  95.     AM2000MenuDesigner8: TMenuItem2000;
  96.     Open1: TMenuItem2000;
  97.     SaveAs1: TMenuItem2000;
  98.     InsStdMnu: TMenuItem2000;
  99.     AM2000MenuDesigner2: TMenuItem2000;
  100.     DefaultBitmaps: TImageList;
  101.     AM2000MenuDesigner5: TMenuItem2000;
  102.     Delete1: TMenuItem2000;
  103.     Bevel3: TBevel;
  104.     ButtonStayOnTop: TSpeedButton;
  105.     MenuTree: T_AM2000_TreeView4;
  106.     SelectAll2: TMenuItem2000;
  107.     DeselectAll1: TMenuItem2000;
  108.     N1: TMenuItem2000;
  109.     btnCut: TSpeedButton;
  110.     btnCopy: TSpeedButton;
  111.     btnPaste: TSpeedButton;
  112.     Bevel4: TBevel;
  113.     ShortCuts1: TMenuItem2000;
  114.     N3: TMenuItem2000;
  115.     procedure MenuTree1Change(Sender: TObject; Node: TTreeNode);
  116.     procedure FormShow(Sender: TObject);
  117.     procedure FormHide(Sender: TObject);
  118.     procedure CollapseAll1Click(Sender: TObject);
  119.     procedure ExpandAll1Click(Sender: TObject);
  120.     procedure ButtonNewMenuItemClick(Sender: TObject);
  121.     procedure ButtonNewSubMenuClick(Sender: TObject);
  122.     procedure MenuTree1Edited(Sender: TObject; Node: TTreeNode;
  123.       var S: String);
  124.     procedure ButtonDeleteClick(Sender: TObject);
  125.     procedure FormKeyUp(Sender: TObject; var Key: Word;
  126.       Shift: TShiftState);
  127.     procedure ButtonMoveDownClick(Sender: TObject);
  128.     procedure ButtonMoveUpClick(Sender: TObject);
  129.     procedure ButtonLevelUpClick(Sender: TObject);
  130.     procedure ButtonLevelDownClick(Sender: TObject);
  131.     procedure LoadFromFile2Click(Sender: TObject);
  132.     procedure SaveToFile2Click(Sender: TObject);
  133.     procedure SaveAsTemplate1Click(Sender: TObject);
  134.     procedure MenuTree1MouseUp(Sender: TObject; Button: TMouseButton;
  135.       Shift: TShiftState; X, Y: Integer);
  136.     procedure LoadBitmapFromFileClick(Sender: TObject);
  137.     procedure PopupMenu20001Popup(Sender: TObject);
  138.     procedure SaveBitmapToFileClick(Sender: TObject);
  139.     procedure None1Click(Sender: TObject);
  140.     procedure ButtonArray1Click(Sender: TObject);
  141.     procedure ButtonArray2Click(Sender: TObject);
  142.     procedure FormDestroy(Sender: TObject);
  143.     procedure AM2000MenuDesigner6Click(Sender: TObject);
  144.     procedure AM2000MenuDesigner7Click(Sender: TObject);
  145.     procedure MenuTree1Editing(Sender: TObject; Node: TTreeNode;
  146.       var AllowEdit: Boolean);
  147.     procedure ButtonStayOnTopClick(Sender: TObject);
  148.     procedure ImageListMenuPopup(Sender: TObject);
  149.     procedure MenuTreeChanging(Sender: TObject; Node: TTreeNode;
  150.       var AllowChange: Boolean);
  151.     procedure MenuTreeMouseDown(Sender: TObject; Button: TMouseButton;
  152.       Shift: TShiftState; X, Y: Integer);
  153.     procedure MenuTreeCustomDrawItem(Sender: TCustomTreeView;
  154.       Node: TTreeNode; State: TCustomDrawState; var DefaultDraw: Boolean);
  155.     procedure FormCreate(Sender: TObject);
  156.     procedure FormClose(Sender: TObject; var Action: TCloseAction);
  157.     procedure DeselectAll1Click(Sender: TObject);
  158.     procedure btnCutClick(Sender: TObject);
  159.     procedure SelectAll2Click(Sender: TObject);
  160.     procedure FormActivate(Sender: TObject);
  161.     procedure btnCopyClick(Sender: TObject);
  162.     procedure btnPasteClick(Sender: TObject);
  163.     procedure Panel1MouseMove(Sender: TObject; Shift: TShiftState; X,
  164.       Y: Integer);
  165.     procedure ShortCuts1Click(Sender: TObject);
  167.   private
  168.     Updating: Boolean;
  169.     TempFolder: String;
  170.     FMenu: TMenu;
  171.     ShiftFirstIndex: Integer;
  172.     LastSelected: TTreeNode;
  173.     SelectedList, // list of selected nodes
  174.     MenuItemList, // list of menu items in the node
  175.     TreeNodeList  // list of tree nodes from MenuItemList
  176.                 : TList;
  178. {$IFDEF Delphi3OrHigher}
  179.     OpenPictureDialog1: TOpenPictureDialog;
  180.     SavePictureDialog1: TSavePictureDialog;
  181. {$ELSE}
  182.     OpenPictureDialog1: TOpenDialog;
  183.     SavePictureDialog1: TSaveDialog;
  184. {$ENDIF}
  186.     procedure CheckConstraints;
  187.     procedure InsertTemplateMenuClick(Sender: TObject);
  188.     procedure SetMenu(const Value: TMenu);
  189.     procedure InvalidateNode(Node: TTreeNode);
  190.     procedure InvalidateList;
  192.     procedure wmSelectComponent(var Msg: TMessage); message wm_SelectComponent;
  193.     procedure wmUpdateCaption(var Msg: TMessage);   message wm_UpdateCaption;
  194.     procedure wmUpdateBitmap(var Msg: TMessage);   message wm_UpdateBitmap;
  195.     procedure UpdateSelections;
  196.     procedure ClearSelections;
  197.     procedure CopySelections;
  199.   protected
  201. {$IFDEF Delphi4OrHigher}
  202.     Designer: IFormDesigner;
  203. {$ELSE}
  204.     Designer: TFormDesigner;
  205. {$ENDIF}
  206.     procedure Loaded; override;
  208.   public
  209.     property Menu: TMenu read FMenu write SetMenu;
  211.   end;
  214.   T_AM2000_TreeView4 = class(TCustomTreeView)
  215.   private
  216.     FCanvas: TCanvas;
  217.     FCanvasChanged: Boolean;
  218.     FOnCustomDrawItem: TTVCustomDrawItemEvent;
  220.     procedure CanvasChanged(Sender: TObject);
  221.     procedure CNNotify(var Message: TWMNotify); message CN_NOTIFY;
  222.     function GetNodeFromItem(const Item: TTVItem): TTreeNode;
  224.   protected
  226.     function CustomDrawItem(Node: TTreeNode; State: TCustomDrawState;
  227.       Stage: TCustomDrawStage
  228. {$IFDEF Delphi5OrHigher}
  229. ;     var PaintImages: Boolean
  230. {$ENDIF}
  231.     ): Boolean;
  232. {$IFDEF Delphi4OrHigher}
  233.     override;
  234. {$ELSE}
  235.     virtual;
  236. {$ENDIF}
  238.     function IsCustomDrawn(Target: TCustomDrawTarget; Stage: TCustomDrawStage): Boolean;
  239.     procedure CreateParams(var Params: TCreateParams); override;
  241.   public
  242.     constructor Create(AOwner: TComponent); override;
  243.     destructor Destroy; override;
  245.     property Canvas: TCanvas read FCanvas;
  247.   published
  248.     property Items;
  249.     property OnChanging;
  250.     property OnChange;
  251.     property Align;
  252.     property OnDragDrop;
  253.     property OnDragOver;
  254.     property OnStartDrag;
  255.     property OnEndDrag;
  256.     property OnMouseDown;
  257.     property OnMouseMove;
  258.     property OnMouseUp;
  259.     property OnDblClick;
  260.     property OnKeyDown;
  261.     property OnKeyPress;
  262.     property OnKeyUp;
  263.     property OnEdited;
  264.     property OnEditing;
  265.     property PopupMenu;
  266.     property Font;
  267.     property Color;
  269.     property OnCustomDrawItem: TTVCustomDrawItemEvent read FOnCustomDrawItem write FOnCustomDrawItem;
  270.   end;
  273. var
  274.   MenuDesignerDlg : T_AM2000_MenuDesignerDlg;
  276. implementation
  278. uses
  279.   Consts, TypInfo, 
  280.   {$IFDEF Delphi2} Ole2, {$ELSE} ShlObj, ActiveX, {$ENDIF}
  281.   {$IFDEF Delphi3orHigher} am2000shortcut, {$ENDIF}
  282.   am2000menubar, am2000const, am2000options;
  284. {$R *.DFM}
  286. const
  287.   MENU_REGISTRY_KEY : String = 'SoftwareAnimatedMenus.comAnimatedMenus/2000Folders';
  288. const
  289.   SOkToDeleteThese = 'Ok to delete these ';
  290.   SSelectedItems = ' selected items?';
  292. {$IFDEF Delphi2}
  294. type
  295.   TSHItemID = record
  296.     cb: Word;                         
  297.     abID: array[0..0] of Byte;        
  298.   end;
  300.   PItemIDList = ^TItemIDList;
  301.   TItemIDList = record
  302.      mkid: TSHItemID;
  303.    end;
  306.   TBrowseInfo = record
  307.     hwndOwner: HWND;
  308.     pidlRoot: PItemIDList;
  309.     pszDisplayName: PAnsiChar;  
  310.     lpszTitle: PAnsiChar;      
  311.     ulFlags: UINT;           
  312.     lpfn: Pointer;
  313.     lParam: LPARAM;         
  314.     iImage: Integer;        
  315.   end;
  318.   function SHBrowseForFolder(var lpbi: TBrowseInfo): PItemIDList;
  319.     stdcall; external 'shell32.dll' name 'SHBrowseForFolderA';
  320.   function SHGetPathFromIDList(pidl: PItemIDList; pszPath: PChar): BOOL;
  321.     stdcall; external 'shell32.dll' name 'SHGetPathFromIDListA';
  323. {$ENDIF}
  325. procedure DrawImageList(Item: TMenuItem2000; ImageList: TImageList);
  326. var
  327.   DX, DY, X, Y: Integer;
  328. begin
  329.   DX:= ImageList.Width +4;
  330.   DY:= ImageList.Height +4;
  332.   with Item.AsButtonArray do begin
  333.     Count:= ImageList.Count;
  334.     Columns:= 9;
  335.     Rows:= Count div Columns;
  336.     if (Count mod Columns) <> 0 then Rows:= Rows +1;
  338.     Bitmap.Width:= Columns * DX;
  339.     Bitmap.Height:= Rows * DY;
  341.     with Bitmap.Canvas do begin
  342.       Brush.Color:= clFuchsia;
  343.       Brush.Style:= bsSolid;
  344.       FillRect(ClipRect);
  345.     end;
  347.     for X:= 0 to Columns do
  348.       for Y:= 0 to Rows do
  349.         ImageList_Draw(ImageList.Handle, X + Y * Columns, Bitmap.Canvas.Handle,
  350.           X * DX +2, Y * DY +2, ild_Transparent);
  351.   end;
  352. end;
  355. { T_AM2000_MenuDesigner }
  357. procedure T_AM2000_MenuDesigner.Edit;
  358. begin
  359.   if not Assigned(MenuDesignerDlg) then
  360.     MenuDesignerDlg:= T_AM2000_MenuDesignerDlg.Create(Application);
  362.   MenuDesignerDlg.Designer:= Designer;
  363.   MenuDesignerDlg.Menu:= TMenu(GetComponent(0));
  364.   MenuDesignerDlg.Show;
  365. end;
  367. function T_AM2000_MenuDesigner.GetValue: string;
  368. begin
  369.   Result:= '(Menu2000)';
  370. end;
  372. function T_AM2000_MenuDesigner.GetAttributes: TPropertyAttributes;
  373. begin
  374.   Result:= [paDialog, paReadOnly];
  375. end;
  378. { T_AM2000_ComponentEditor }
  380. procedure T_AM2000_ComponentEditor.Edit;
  381. begin
  382.   if not Assigned(MenuDesignerDlg) then
  383.     MenuDesignerDlg:= T_AM2000_MenuDesignerDlg.Create(Application);
  385.   MenuDesignerDlg.Designer:= Designer;
  386.   MenuDesignerDlg.Menu:= TMenu(Component);
  387.   MenuDesignerDlg.Show;
  388. end;
  390. function T_AM2000_ComponentEditor.GetVerbCount: Integer;
  391. begin
  392.   Result:= inherited GetVerbCount + 1;
  393. end;
  395. function T_AM2000_ComponentEditor.GetVerb(Index: Integer): String;
  396. begin
  397.   if Index = 0
  398.   then Result:= 'AM2000 Menu Designer...'
  399.   else Result:= inherited GetVerb(Index -1);
  400. end;
  402. procedure T_AM2000_ComponentEditor.ExecuteVerb(Index: Integer);
  403. begin
  404.   if Index = 0 then Edit;
  405. end;
  408. { TMenuDesignerDlg }
  410. procedure T_AM2000_MenuDesignerDlg.CheckConstraints;
  411. var
  412.   P: Boolean;
  413.   S: TTreeNode;
  415.   function IsClipboardObject: Boolean;
  416.     // checks is object in lcipboard
  417.   begin
  418.     Result:= LowerCase(Copy(Trim(PasteFromClipboard), 1, 6)) = 'object';
  419.   end;
  421. begin
  422.   S:= MenuTree.Selected;
  423.   P:= (S <> nil) and (S.Parent <> nil);
  425.   ButtonDelete.Enabled:= P and (SelectedList.Count > 0);
  426.   ButtonLevelUp.Enabled:= P and (S.Parent.Parent <> nil);
  427.   ButtonMoveUp.Enabled:= P and ((S.GetPrevSibling <> nil) or (S.Parent.GetPrevSibling <> nil));
  428.   ButtonMoveDown.Enabled:=  P and ((S.GetNextSibling <> nil) or (S.Parent.GetNextSibling <> nil));
  429.   ButtonLevelDown.Enabled:= P;
  430.   DefaultBitmaps1.Enabled:= P;
  431.   ImageListBitmaps1.Enabled:= P and (not ButtonArray2.AsButtonArray.Bitmap.Empty);
  432.   LoadBitmapFromFile1.Enabled:= P;
  433.   SaveBitmapToFile1.Enabled:= P;
  434.   NewItem1.Enabled:= P;
  435.   ButtonNewMenuItem.Enabled:= P;
  437.   // cut/copy/paste
  438.   btnPaste.Enabled:= P and IsClipboardFormatAvailable(cf_Text) and IsClipboardObject;
  439.   btnCut.Enabled:= ButtonDelete.Enabled;
  440.   btnCopy.Enabled:= (SelectedList.Count > 0);
  441. end;
  443. procedure T_AM2000_MenuDesignerDlg.InvalidateNode(Node: TTreeNode);
  444. var
  445.   R: TRect;
  446. begin
  447.   if (Node = nil) or Updating then Exit;
  449.   try
  450.     R:= Node.DisplayRect(False);
  451.     InvalidateRect(MenuTree.Handle, @R, False)
  452.   except
  453.   end;
  454. end;
  456. procedure T_AM2000_MenuDesignerDlg.InvalidateList;
  457. var
  458.   I: Integer;
  459. begin
  460.   for I:= 0 to SelectedList.Count -1 do
  461.     InvalidateNode(TTreeNode(SelectedList[I]));
  462. end;
  464. procedure T_AM2000_MenuDesignerDlg.MenuTree1Change(Sender: TObject;
  465.   Node: TTreeNode);
  466. var
  467.   M: TMenuItem2000;
  468.   S: String;
  469.   B: Boolean;
  470.   N: TTreeNode;
  471. begin
  472.   CheckConstraints;
  474.   if (not (Assigned(Node) and Assigned(Node.Data)))
  475.   or (Updating)
  476.   then Exit;
  478.   try
  479.     S:= '';
  480.     if TObject(Node.Data) is TMenuItem2000 then begin
  481.       M:= TMenuItem2000(Node.Data);
  482.       while Assigned(M) and (M.Caption <> '') do begin
  483.         if S <> ''then S:= ' | ' + S;
  484.         S:= M.Caption + S;
  485.         M:= M.Parent;
  486.       end;
  487.     end;
  489.     // set item index at ButtonArray1
  490.     if Assigned(Node.Data) then
  491.       with TMenuItem2000(Node.Data) do begin
  492.         IgnoreRepaintFloating:= True;
  493.         ButtonArray1.AsButtonArray.ItemIndex:= DefaultIndex;
  494.         ButtonArray2.AsButtonArray.ItemIndex:= ImageIndex;
  495.         IgnoreRepaintFloating:= False;
  497.         B:= (DefaultIndex = -1) and (ImageIndex = -1);
  498.         None1.AsButton.Down:= B;
  499.         None2.AsButton.Down:= B;
  500.       end;
  502.   except
  503.   end;
  505.   // custom draw support
  506.   if Node = nil then Exit;
  508.   // shift
  509.   if GetKeyState(vk_Shift) < 0
  510.   then begin
  511.     InvalidateList;
  512.     SelectedList.Clear;
  513.     N:= Node;
  515.     while (N <> nil) and (N.AbsoluteIndex <> ShiftFirstIndex)
  516.     do begin
  517.       SelectedList.Add(N);
  518.       InvalidateNode(N);
  519.       if N.AbsoluteIndex < ShiftFirstIndex
  520.       then N:= N.GetNextVisible
  521.       else N:= N.GetPrevVisible;
  522.     end;
  524.     if N <> nil then begin
  525.       SelectedList.Add(N);
  526.       InvalidateNode(N);
  527.     end;
  528.   end
  530.   else
  531.   // control
  532.   if GetKeyState(vk_Control) < 0
  533.   then begin
  534.     if Node <> nil then begin
  535.       if SelectedList.IndexOf(Node) = -1
  536.       then SelectedList.Add(Node)
  537.       else SelectedList.Remove(Node);
  539.       InvalidateNode(Node);
  540.     end;
  541.   end
  543.   // none
  544.   else begin
  545.     ShiftFirstIndex:= -1;
  546.     InvalidateList;
  547.     SelectedList.Clear;
  548.     SelectedList.Add(Node);
  549.     InvalidateNode(Node);
  550.   end;
  552.   UpdateSelections;
  553. end;
  555. procedure T_AM2000_MenuDesignerDlg.MenuTreeChanging(Sender: TObject;
  556.   Node: TTreeNode; var AllowChange: Boolean);
  557. var
  558.   N: TTreeNode;
  559. begin
  560.   N:= MenuTree.Selected;
  562.   // check keys
  563.   if (GetKeyState(vk_Shift) < 0)
  564.   and (N <> nil)
  565.   and (ShiftFirstIndex = -1)
  566.   then ShiftFirstIndex:= N.AbsoluteIndex;
  567. end;
  569. procedure T_AM2000_MenuDesignerDlg.MenuTreeCustomDrawItem(
  570.   Sender: TCustomTreeView; Node: TTreeNode; State: TCustomDrawState;
  571.   var DefaultDraw: Boolean);
  572. var
  573.   txtRect, R: TRect;
  574.   Bitmap: HBitmap;
  575.   NumGlyphs, BitmapIndex, DX: Integer;
  576.   mi: TMenuItem2000;
  577.   img: TImageList;
  578. begin
  579.   DX:= -20;
  580.   Bitmap:= 0;
  581.   BitmapIndex:= -1;
  582.   DefaultDraw:= False;  
  583.   with T_AM2000_TreeView4(Sender), Canvas, Node do begin
  584.     txtRect:= DisplayRect(True);
  586.     Font.Assign(T_AM2000_TreeView4(Sender).Font);
  587.     if (SelectedList.IndexOf(Node) <> -1)
  588.     and (Node.Parent <> nil)
  589.     then begin
  590.       Brush.Color:= clHighlight;
  591.       Font.Color:= clHighlightText;
  592.     end
  593.     else begin
  594.       Brush.Color:= T_AM2000_TreeView4(Sender).Color;
  595.     end;
  597.     // selection
  598.     FillRect(DisplayRect(False));
  600.     // caption
  601.     R:= txtRect;
  602.     R.Right:= Width;
  603.     DrawText(Canvas.Handle, PChar(Text), Length(Text), R, dt_SingleLine + dt_VCenter);
  606.     if HasChildren
  607.     then begin // draw button
  608.       Dec(DX, 13);
  609.       R:= Rect(0, 0, 9, 9);
  610.       OffsetRect(R, txtRect.Left -14, (txtRect.Bottom + txtRect.Top) div 2 -5);
  611.       Brush.Color:= T_AM2000_TreeView4(Sender).Color;
  612.       FillRect(R);
  614.       Brush.Color:= clBtnShadow;
  615.       FrameRect(R);
  617.       Pen.Color:= T_AM2000_TreeView4(Sender).Font.Color;
  618.       Pen.Style:= psSolid;
  619.       if Expanded then begin
  620.         PolyLine([Point(R.Left +2, R.Top +4), Point(R.Right -2, R.Top +4)]);
  621.       end
  622.       else begin
  623.         PolyLine([Point(R.Left +4, R.Top +2), Point(R.Left +4, R.Bottom -2)]);
  624.         PolyLine([Point(R.Left +2, R.Top +4), Point(R.Right -2, R.Top +4)]);
  625.       end;
  626.     end;
  628.     mi:= TMenuItem2000(Data);
  629.     if mi = nil then Exit;
  631.     // draw bitmap
  632. {$IFDEF Delphi4OrHigher}
  633.     img:= TImageList(TMainMenu(FMenu).Images);
  634. {$ELSE}
  635.     if FMenu is TMainMenu2000
  636.     then
  637.       img:= TMainMenu2000(FMenu).Images
  638.     else
  639.     if FMenu is TPopupMenu2000
  640.     then
  641.       img:= TPopupMenu2000(FMenu).Images
  642.     else
  643.       img:= nil;
  644. {$ENDIF}
  647.     if (mi is TMenuItem2000)
  648.     and (TMenuItem2000(mi).IsBitmapAssigned)
  649.     then
  650.       Bitmap:= TMenuItem2000(mi).GetBitmapEx.Handle
  652.     else
  653.     if
  654.     (img <> nil) and
  655. {$IFDEF Delphi4OrHigher}
  656.     (mi.ImageIndex <> -1)
  657. {$ELSE}
  658.     (mi is TMenuItem2000) and (TMenuItem2000(mi).ImageIndex <> -1)
  659. {$ENDIF}
  660.     then
  661.       BitmapIndex:= TMenuItem2000(mi).ImageIndex
  663.     else
  664. {$IFDEF Delphi4OrHigher}
  665.       Bitmap:= mi.Bitmap.Handle;
  666. {$ELSE}
  667.       Bitmap:= 0;
  668. {$ENDIF}
  670.     if mi is TMenuItem2000
  671.     then NumGlyphs:= TMenuItem2000(mi).NumGlyphs
  672.     else NumGlyphs:= 0;
  674.     if (Bitmap = 0)
  675.     and (BitmapIndex = -1)
  676.     and mi.Checked
  677.     then
  678.       if mi.RadioItem
  679.       then Bitmap:= bmpRadioItem
  680.       else Bitmap:= bmpCheckMark;
  682.     if (Bitmap <> 0) or (BitmapIndex <> -1)
  683.     then begin
  684.       R:= Rect(0, 0, 16, 16);
  685.       OffsetRect(R, txtRect.Left + DX, (txtRect.Bottom + txtRect.Top) div 2 -9);
  686.       DrawBitmap(Canvas, Bitmap, BitmapIndex, NumGlyphs, 0, [], nil, R, img);
  687.     end;
  688. //    DeleteObject(Bitmap);
  689.   end;
  690. end;
  692. procedure T_AM2000_MenuDesignerDlg.MenuTreeMouseDown(Sender: TObject;
  693.   Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
  694. var
  695.   N: TTreeNode;
  696. begin
  697.   N:= nil;
  698.   with MenuTree do begin
  699.     if not (htOnButton in GetHitTestInfoAt(X, Y))
  700.     then N:= GetNodeAt(X, Y);
  702.     if (N <> nil)
  703.     and (N = Selected)
  704.     then begin
  705.       if (GetKeyState(vk_Control) < 0)
  706.       and (N = LastSelected)
  707.       then begin
  708.         if SelectedList.IndexOf(N) = -1
  709.         then SelectedList.Add(N)
  710.         else SelectedList.Remove(N);
  712.         TreeView_EndEditLabelNow(N.Handle, True);
  713.         UpdateSelections;
  714.       end
  715.       else
  716.         if SelectedList.IndexOf(N) = -1
  717.         then begin
  718.           InvalidateList;
  719.           SelectedList.Clear;
  720.           SelectedList.Add(N);
  721.         end
  722.     end
  723.     else
  724.       Selected:= N;
  726.     InvalidateNode(LastSelected);
  727.     InvalidateNode(N);
  728.     LastSelected:= N;  
  729.   end;
  731.   CheckConstraints;
  732. end;
  734. procedure T_AM2000_MenuDesignerDlg.Loaded;
  735. var
  736.   Reg: TRegistry;
  737.   SI: TSearchRec;
  738.   I, Res, DX, DY, X, Y: Integer;
  739.   mici: T_AM2000_MenuItemCacheItem;
  740. //  BlankColor: ColorRef;
  741. //  hbmp: HBitmap;
  742.   B: Boolean;
  743.   lpbi: TBrowseInfo;
  744.   pid2: PItemIDList;
  745.   z: array [0..MAX_PATH] of Char;
  746. begin
  747.   inherited;
  749.   // load autobitmaps & autohints
  750. //  BlankColor:= ColorToRGB(clFuchsia);
  752.   Res:= 0;
  753.   for I:= 0 to MenuItemCache.Count -1 do
  754.     with T_AM2000_MenuItemCacheItem(TStringList(MenuItemCache).Objects[I]) do
  755.       if (Bitmap <> 0) and IsDefault
  756.       then Inc(Res);
  758.   with ButtonArray1.AsButtonArray do begin
  759.     X:= 0;
  760.     Y:= 0;
  761.     DX:= 20;
  762.     DY:= 20;
  763.     Columns:= 9;
  764.     Rows:= Res div Columns;
  765.     if Res mod Columns <> 0 then Rows:= Rows +1;
  766.     Bitmap.Width:= Columns * DX;
  767.     Bitmap.Height:= Rows * DY;
  768.     Bitmap.Canvas.Brush.Color:= clBtnFace;
  769.     Bitmap.Canvas.FillRect(Bitmap.Canvas.ClipRect);
  771.     for I:= 0 to MenuItemCache.Count -1 do begin
  772.       mici:= T_AM2000_MenuItemCacheItem(TStringList(MenuItemCache).Objects[I]);
  773.       if (mici.Bitmap <> 0)
  774.       and (mici.IsDefault)
  775.       then begin
  776.         TransBlt(Bitmap.Canvas, X * DX +2, Y * DY + 2, 0, 1, mici.Bitmap);
  778.         if mici.Hint <> ''
  779.         then Hints.Add(mici.Hint)
  780.         else Hints.Add(TStringList(MenuItemCache)[I]);
  782.         Inc(X);
  783.         if X >= Columns then begin
  784.           Inc(Y);
  785.           X:= 0;
  786.         end;
  787.       end;
  788.     end;
  789.   end;
  791. {$IFDEF Delphi3OrHigher}
  792.   // set flat property
  793.   ButtonNewMenuItem.Flat:= True;
  794.   ButtonNewSubMenu.Flat:= True;
  795.   ButtonDelete.Flat:= True;
  796.   ButtonLevelUp.Flat:= True;
  797.   ButtonMoveUp.Flat:= True;
  798.   ButtonMoveDown.Flat:= True;
  799.   ButtonLevelDown.Flat:= True;
  800.   ButtonStayOnTop.Flat:= True;
  801.   btnCut.Flat:= True;
  802.   btnCopy.Flat:= True;
  803.   btnPaste.Flat:= True;
  804. {$ENDIF}
  807.   // load menu templates
  808.   Reg:= TRegistry.Create;
  809.   B:= Reg.OpenKey(MENU_REGISTRY_KEY, False);
  810.   if not B then begin
  811.     FillChar(lpbi, SizeOf(lpbi), 0);
  812.     lpbi.hwndOwner:= Application.MainForm.Handle;
  813.     lpbi.lpszTitle:= SBrowseForMenuTemplateFolder;
  814.     pid2:= SHBrowseForFolder(lpbi);
  815.     if pid2 = nil then Exit;
  817.     Reg.OpenKey(MENU_REGISTRY_KEY, True);
  818.     SHGetPathFromIDList(pid2, z);
  819.     TempFolder:= StrPas(z);
  820.     Reg.WriteString('MenuTemplatesFolder', TempFolder);
  821.     CoTaskMemFree(pid2);
  822.   end
  823.   else
  824.     TempFolder:= Reg.ReadString('MenuTemplatesFolder');
  826.   // scan template files
  827.   if (Length(TempFolder) > 0)
  828.   and (TempFolder[Length(TempFolder)] <> '')
  829.   then AppendStr(TempFolder, '');
  831.   Res:= FindFirst(TempFolder + '*.mnu', faAnyFile, SI);
  832.   while Res = 0 do begin
  833.     InsStdMnu.Add(NewItem(ChangeFileExt(SI.Name, ''), 0,
  834.       False, True, InsertTemplateMenuClick, 0, ''));
  836.     Res:= FindNext(SI);
  837.   end;
  838.   FindClose(SI);
  840.   Reg.Free;
  841. end;
  843. procedure T_AM2000_MenuDesignerDlg.FormShow(Sender: TObject);
  844. begin
  845.   // create and initialize dialogs
  846. {$IFDEF Delphi3OrHigher}
  847.   OpenPictureDialog1:= TOpenPictureDialog.Create(Self);
  848.   SavePictureDialog1:= TSavePictureDialog.Create(Self);
  849. {$ELSE}
  850.   OpenPictureDialog1:= TOpenDialog.Create(Self);
  851.   SavePictureDialog1:= TSaveDialog.Create(Self);
  852. {$ENDIF}
  854.   with OpenPictureDialog1 do begin
  855.     DefaultExt:= 'bmp';
  856.     Filter:= SBitmapDialogFilter;
  857.     Options:= [ofHideReadOnly, ofPathMustExist, ofFileMustExist];
  858.     Title:= SOpenBitmapDialogTitle;
  859.   end;
  861.   with SavePictureDialog1 do begin
  862.     DefaultExt:= 'bmp';
  863.     FileName:= 'Untitled-1.bmp';
  864.     Filter:= SBitmapDialogFilter;
  865.     Options:= [ofOverwritePrompt, ofHideReadOnly, ofPathMustExist];
  866.     Title:= SSaveBitmapDialogTitle;
  867.   end;
  868. end;
  870. procedure T_AM2000_MenuDesignerDlg.FormHide(Sender: TObject);
  871. begin
  872.   Designer:= nil;
  873. end;
  875. procedure T_AM2000_MenuDesignerDlg.FormCreate(Sender: TObject);
  876. begin
  877.   Updating:= False;
  878.   SelectedList:= TList.Create;
  879.   MenuItemList:= TList.Create;
  880.   TreeNodeList:= TList.Create;
  881. end;
  883. procedure T_AM2000_MenuDesignerDlg.FormDestroy(Sender: TObject);
  884. begin
  885.   Updating:= True;
  886.   SelectedList.Free;
  887.   MenuItemList.Free;
  888.   TreeNodeList.Free;
  889.   MenuDesignerDlg:= nil;
  890. end;
  892. procedure T_AM2000_MenuDesignerDlg.CollapseAll1Click(Sender: TObject);
  893. begin
  894.   MenuTree.FullCollapse;
  895. end;
  897. procedure T_AM2000_MenuDesignerDlg.ExpandAll1Click(Sender: TObject);
  898. begin
  899.   MenuTree.FullExpand;
  900. end;
  902. procedure T_AM2000_MenuDesignerDlg.ButtonNewMenuItemClick(Sender: TObject);
  903. var
  904.   N, N1: TTreeNode;
  905.   M, M1: TMenuItem2000;
  906. begin
  907.   N:= MenuTree.Selected;
  908.   if (not Assigned(N))
  909.   or (not Assigned(N.Parent)) then Exit;
  911.   // clear selection
  912.   InvalidateList;
  913.   SelectedList.Clear;
  914.   SelectedList.Add(N);
  915.   InvalidateNode(N);
  917.   M:= TMenuItem2000(N.Data);
  918.   M1:= TMenuItem2000.Create(Menu.Owner);
  919.   M1.Caption:= SDefaultMenuItemCaption;
  921.   if Designer <> nil
  922.   then M1.Name:= Designer.UniqueName('MenuItem');
  924.   if (N.GetNextSibling <> nil) then begin
  925.     N1:= MenuTree.Items.Insert(N.GetNextSibling, SDefaultMenuItemCaption);
  926.     M.Parent.Insert(M.MenuIndex +1, M1);
  927.   end
  928.   else begin
  929.     N1:= MenuTree.Items.Add(N, SDefaultMenuItemCaption);
  930.     M.Parent.Add(M1);
  931.   end;
  933.   if Designer <> nil then begin
  934.     Designer.Modified;
  935.     Designer.SelectComponent(M1);
  936.   end;
  938.   if ActiveMenuBar <> nil
  939.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  941.   N1.Selected:= True;
  942.   N1.Data:= M1;
  943.   TreeNodeList.Add(N1);
  944.   MenuItemList.Add(N1.Data);
  946.   // customdraw
  947.   InvalidateList;
  948.   SelectedList.Clear;
  949.   SelectedList.Add(N1);
  950.   InvalidateNode(N1);
  952.   if ActiveMenuBar <> nil
  953.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  955.   N1.EditText;
  956.   CheckConstraints;
  957. end;
  959. procedure T_AM2000_MenuDesignerDlg.ButtonNewSubMenuClick(Sender: TObject);
  960. var
  961.   N: TTreeNode;
  962.   M: TMenuItem2000;
  963. begin
  964.   if not Assigned(MenuTree.Selected) then Exit;
  965.   N:= MenuTree.Items.AddChild(MenuTree.Selected, SDefaultMenuItemCaption);
  967.   // clear selection
  968.   InvalidateList;
  969.   SelectedList.Clear;
  970.   SelectedList.Add(N);
  971.   InvalidateNode(N);
  973.   M:= TMenuItem2000.Create(Menu.Owner);
  974.   M.Caption:= SDefaultMenuItemCaption;
  975.   
  976.   if Designer <> nil
  977.   then M.Name:= Designer.UniqueName('MenuItem');
  979.   TMenuItem2000(MenuTree.Selected.Data).Add(M);
  980.   MenuTree.Selected.Expand(False);
  982.   if Designer <> nil then begin
  983.     Designer.SelectComponent(M);
  984.     Designer.Modified;
  985.   end;
  987.   if ActiveMenuBar <> nil
  988.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  990.   N.Selected:= True;
  991.   N.Data:= M;
  992.   TreeNodeList.Add(N);
  993.   MenuItemList.Add(N.Data);
  995.   // customdraw
  996.   InvalidateList;
  997.   SelectedList.Clear;
  998.   SelectedList.Add(N);
  999.   InvalidateNode(N);
  1001.   if ActiveMenuBar <> nil
  1002.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1004.   N.EditText;
  1005.   CheckConstraints;
  1006. end;
  1008. procedure T_AM2000_MenuDesignerDlg.MenuTree1Edited(Sender: TObject; Node: TTreeNode;
  1009.   var S: String);
  1010. var
  1011.   M: TMenuItem2000;
  1012.   S1, S2: String;
  1013. begin
  1014.   if Node.Parent <> nil then begin
  1015.     // generate menu item capion
  1016.     M:= TMenuItem2000(Node.Data);
  1017.     M.Caption:= S;
  1018.     S1:= S;
  1020.     while (M.Parent <> nil) do begin
  1021.       M:= M.Parent;
  1022.       S1:= M.Caption + S1;
  1023.     end;
  1025.     if Designer <> nil then begin
  1026.       // set menu item name
  1027.       S1:= GetValidName(S1);
  1028.       if S1 = '' then S1:= 'N';
  1030.       S2:= Designer.UniqueName(S1);
  1031.       if (S1[1] = 'T') and (S2[1] <> 'T')
  1032.       then S2:= 'T' + S2;
  1034.       TMenuItem2000(Node.Data).Name:= S2;
  1035.       Designer.Modified;
  1036.       Designer.SelectComponent(TMenuItem2000(Node.Data));
  1037.     end;
  1039.     if ActiveMenuBar <> nil
  1040.     then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1041.   end;
  1042. end;
  1044. procedure T_AM2000_MenuDesignerDlg.ButtonDeleteClick(Sender: TObject);
  1045. begin
  1046.   if (SelectedList.Count > 1)
  1047.   and (MessageDlg(SOkToDeleteThese + IntToStr(SelectedList.Count) + SSelectedItems, mtConfirmation,
  1048.     mbOkCancel, 0) <> mrOk)
  1049.   then Exit;
  1051.   ClearSelections;
  1052.   LastSelected:= nil;
  1054. end;
  1056. procedure T_AM2000_MenuDesignerDlg.FormKeyUp(Sender: TObject; var Key: Word;
  1057.   Shift: TShiftState);
  1058. var
  1059.   S: String;
  1060. begin
  1061.   if MenuTree.IsEditing
  1062.   then
  1063.     case Key of
  1064.       vk_Return:
  1065.         ButtonNewMenuItemClick(nil);
  1066.       vk_Escape:
  1067.         if MenuTree.Selected.Text = SDefaultMenuItemCaption
  1068.         then ButtonDeleteClick(nil);
  1069.     end
  1070.   else
  1071.     case Key of
  1072.       vk_Insert:
  1073.         ButtonNewMenuItemClick(nil);
  1074.       vk_Delete:
  1075.         ButtonDeleteClick(nil);
  1076.       vk_F2:
  1077.         if ssCtrl in Shift
  1078.         then begin
  1079.           S:= TMenuItem2000(MenuTree.Selected.Data).Caption;
  1080.           MenuTree1Edited(nil, MenuTree.Selected, S);
  1081.         end
  1082.         else MenuTree.Selected.EditText;
  1083.       vk_Up:
  1084.         if ssCtrl in Shift
  1085.         then ButtonMoveUpClick(nil);
  1086.       vk_Down:
  1087.         if ssCtrl in Shift
  1088.         then ButtonMoveDownClick(nil);
  1089.       vk_Right:
  1090.         if ssCtrl in Shift
  1091.         then ButtonLevelDownClick(nil);
  1092.       vk_Left:
  1093.         if ssCtrl in Shift
  1094.         then ButtonLevelUpClick(nil);
  1095.     end;
  1096.   CheckConstraints;
  1097. end;
  1099. procedure T_AM2000_MenuDesignerDlg.ButtonMoveDownClick(Sender: TObject);
  1100. var
  1101.   N, N1: TTreeNode;
  1102.   M, M1: TMenuItem2000;
  1103. begin
  1104.   N:= MenuTree.Selected;
  1105.   if (not Assigned(N))
  1106.   or (not Assigned(N.Parent)) then Exit;
  1108.   // clear selection
  1109.   InvalidateList;
  1110.   SelectedList.Clear;
  1111.   SelectedList.Add(N);
  1112.   InvalidateNode(N);
  1114.   N1:= N.GetNextSibling;
  1116.   // updating
  1117.   Updating:= True;
  1118.   MenuTree.Items.BeginUpdate;
  1120.   if Assigned(N1)
  1121.   then begin
  1122.     N1:= N1.GetNextSibling;
  1124.     if Assigned(N1)
  1125.     then N.MoveTo(N1, naInsert)
  1126.     else N.MoveTo(N.Parent, naAddChild);
  1128.     with TMenuItem2000(N.Data) do MenuIndex:= MenuIndex +1;
  1130.   end
  1131.   else begin
  1132.     N1:= N.Parent.GetNextSibling;
  1133.     if Assigned(N1) then begin
  1134.       N.MoveTo(N1, naAddChildFirst);
  1136.       M:= TMenuItem2000(N.Data);
  1137.       M1:= M.Parent.Parent.Items[M.Parent.MenuIndex +1];
  1138.       M.Parent.Remove(M);
  1139.       M1.Insert(0, M);
  1140.     end
  1141.   end;
  1143.   MenuTree.Items.EndUpdate;
  1144.   Updating:= False;
  1146.   CheckConstraints;
  1148.   if ActiveMenuBar <> nil
  1149.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1150.   
  1151. end;
  1153. procedure T_AM2000_MenuDesignerDlg.ButtonMoveUpClick(Sender: TObject);
  1154. var
  1155.   N, N1: TTreeNode;
  1156.   M, M1: TMenuItem2000;
  1157. begin
  1158.   N:= MenuTree.Selected;
  1159.   if (not Assigned(N))
  1160.   or (not Assigned(N.Parent)) then Exit;
  1162.   // clear selection
  1163.   InvalidateList;
  1164.   SelectedList.Clear;
  1165.   SelectedList.Add(N);
  1166.   InvalidateNode(N);
  1168.   N1:= N.GetPrevSibling;
  1169.   if N1 = N.Parent then Exit;
  1171.   // updating
  1172.   Updating:= True;
  1173.   MenuTree.Items.BeginUpdate;
  1175.   if Assigned(N1) then begin
  1176.     N.MoveTo(N1, naInsert);
  1177.     with TMenuItem2000(N.Data) do MenuIndex:= MenuIndex -1;
  1178.   end
  1179.   else begin
  1180.     N1:= N.Parent.GetPrevSibling;
  1181.     if Assigned(N1) then begin
  1182.       N.MoveTo(N1, naAddChild);
  1184.       M:= TMenuItem2000(N.Data);
  1185.       M1:= M.Parent.Parent.Items[M.Parent.MenuIndex -1];
  1186.       M.Parent.Remove(M);
  1187.       M1.Add(M);
  1189.     end;
  1190.   end;
  1192.   MenuTree.Items.EndUpdate;
  1193.   Updating:= False;
  1194.   CheckConstraints;
  1196.   if ActiveMenuBar <> nil
  1197.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1199. end;
  1201. procedure T_AM2000_MenuDesignerDlg.ButtonLevelUpClick(Sender: TObject);
  1202. var
  1203.   N, N1: TTreeNode;
  1204.   M, M1: TMenuItem2000;
  1205.   I: Integer;
  1206. begin
  1207.   N:= MenuTree.Selected;
  1208.   if (not Assigned(N))
  1209.   or (not Assigned(N.Parent))
  1210.   or (not Assigned(N.Parent.Parent)) then Exit;
  1212.   // clear selection
  1213.   InvalidateList;
  1214.   SelectedList.Clear;
  1215.   SelectedList.Add(N);
  1216.   InvalidateNode(N);
  1218.   N1:= N.Parent.GetNextSibling;
  1220.   // updating
  1221.   Updating:= True;
  1222.   MenuTree.Items.BeginUpdate;
  1224.   M:= TMenuItem2000(N.Data);
  1225.   M1:= M.Parent.Parent;
  1226.   I:= M.Parent.MenuIndex;
  1227.   M.Parent.Remove(M);
  1229.   if Assigned(N1) then begin
  1230.     N.MoveTo(N1, naInsert);
  1231.     M1.Insert(I +1, M);
  1233.   end
  1234.   else begin
  1235.     N.MoveTo(N.Parent.Parent, naAddChild);
  1236.     M1.Add(M);
  1238.   end;
  1240.   MenuTree.Items.EndUpdate;
  1241.   Updating:= False;
  1242.   CheckConstraints;
  1244.   if ActiveMenuBar <> nil
  1245.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1247. end;
  1249. procedure T_AM2000_MenuDesignerDlg.ButtonLevelDownClick(Sender: TObject);
  1250. var
  1251.   N, N1: TTreeNode;
  1252.   M, M1, M2: TMenuItem2000;
  1253.   I: Integer;
  1254. begin
  1255.   N:= MenuTree.Selected;
  1256.   if (not Assigned(N))
  1257.   or (not Assigned(N.Parent)) then Exit;
  1259.   // clear selection
  1260.   InvalidateList;
  1261.   SelectedList.Clear;
  1262.   SelectedList.Add(N);
  1263.   InvalidateNode(N);
  1265.   // treeview...
  1266.   N1:= N.GetPrevSibling;
  1268.   // updating
  1269.   Updating:= True;
  1270.   MenuTree.Items.BeginUpdate;
  1272.   // menu...
  1273.   M:= TMenuItem2000(N.Data);
  1274.   M1:= M.Parent;
  1275.   I:= M.MenuIndex;
  1276.   M.Parent.Remove(M);
  1278.   if Assigned(N1)
  1279.   then begin
  1280.     N.MoveTo(N1, naAddChild);
  1281.     M1[I -1].Add(M);
  1282.   end
  1283.   else begin
  1284.     N1:= MenuTree.Items.AddChildFirst(N.Parent, SDefaultMenuItemCaption);
  1285.     N.MoveTo(N1, naAddChild);
  1287.     M2:= TMenuItem2000.Create(Menu.Owner);
  1288.     M2.Caption:= SDefaultMenuItemCaption;
  1290.     if Designer <> nil
  1291.     then M2.Name:= Designer.UniqueName('MenuItem');
  1293.     M2.Add(M);
  1294.     M1.Insert(0, M2);
  1296.     N1.Data:= M2;
  1297.     TreeNodeList.Add(N1);
  1298.     MenuItemList.Add(N1.Data);
  1300.   end;
  1302.   MenuTree.Items.EndUpdate;
  1303.   Updating:= False;
  1304.   CheckConstraints;
  1306.   if ActiveMenuBar <> nil
  1307.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1308.   
  1309. end;
  1311. procedure T_AM2000_MenuDesignerDlg.wmUpdateCaption(var Msg: TMessage);
  1312. var
  1313.   I: Integer;
  1314. begin
  1315.   // get menu item index
  1316.   I:= MenuItemList.IndexOf(Pointer(Msg.LParam));
  1317.   // get tree node
  1318.   if I <> -1 then InvalidateNode(TTreeNode(TreeNodeList[I]));
  1319. end;
  1321. procedure T_AM2000_MenuDesignerDlg.wmUpdateBitmap(var Msg: TMessage);
  1322. var
  1323.   I: Integer;
  1324. begin
  1325.   // get menu item index
  1326.   I:= MenuItemList.IndexOf(Pointer(Msg.LParam));
  1327.   // get tree node
  1328.   if I <> -1 then InvalidateNode(TTreeNode(TreeNodeList[I]));
  1329. end;
  1332. procedure T_AM2000_MenuDesignerDlg.LoadFromFile2Click(Sender: TObject);
  1333.   // loads menu from file
  1334. var
  1335.   M, M1: TMenuItem2000;
  1336. begin
  1337.   if (MenuTree.Selected = nil)
  1338.   or (not OpenDialog1.Execute)
  1339.   then Exit;
  1341.   M:= TMenuItem2000(MenuTree.Selected.Data);
  1342.   M1:= TMenuItem2000.Create(Menu.Owner);
  1343.   ReadComponentResFile(OpenDialog1.Filename, M1);
  1345.   M.Insert(0, M1);
  1346.   Menu:= Menu;
  1348.   if Designer <> nil
  1349.   then Designer.Modified;
  1351.   if ActiveMenuBar <> nil
  1352.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1353. end;
  1355. procedure T_AM2000_MenuDesignerDlg.InsertTemplateMenuClick(Sender: TObject);
  1356.   // loads a template menu
  1357. var
  1358.   S: String;
  1359.   M, M1: TMenuItem2000;
  1360. begin
  1361.   S:= TempFolder + TMenuItem2000(Sender).Caption + '.mnu';
  1363.   if (MenuTree.Selected = nil)
  1364.   or (not FileExists(S))
  1365.   then Exit;
  1367.   M:= TMenuItem2000(MenuTree.Selected.Data);
  1368.   M1:= TMenuItem2000.Create(Menu.Owner);
  1369.   ReadComponentResFile(S, M1);
  1371.   M.Insert(0, M1);
  1372.   Menu:= Menu;
  1374.   if Designer <> nil
  1375.   then Designer.Modified;
  1377.   // update menu bar
  1378.   if ActiveMenuBar <> nil
  1379.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1381. end;
  1383. procedure T_AM2000_MenuDesignerDlg.SaveToFile2Click(Sender: TObject);
  1384.   // saves menu to a file
  1385. begin
  1386.   if (not SaveDialog1.Execute)
  1387.   then Exit;
  1389.   with MenuTree.Selected do
  1390.     WriteComponentResFile(SaveDialog1.Filename, TMenuItem2000(Data));
  1391. end;
  1393. procedure T_AM2000_MenuDesignerDlg.SaveAsTemplate1Click(Sender: TObject);
  1394.   // saves menu as an template
  1395. begin
  1396.   SaveDialog1.InitialDir:= TempFolder;
  1397.   if not SaveDialog1.Execute
  1398.   then Exit;
  1400.   with MenuTree.Selected do
  1401.     WriteComponentResFile(SaveDialog1.Filename, TMenuItem2000(Data));
  1402. end;
  1404. procedure T_AM2000_MenuDesignerDlg.MenuTree1MouseUp(Sender: TObject;
  1405.   Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
  1406.   // pops up a right-click menu
  1407. var
  1408.   N: TTreeNode;
  1409. begin
  1410.   if (Button <> mbRight)
  1411.   then Exit;
  1413.   N:= MenuTree.GetNodeAt(X, Y);
  1414.   if N <> nil
  1415.   then
  1416.     with MenuTree.ClientToScreen(Point(X, Y)) do
  1417.       PopupMenu20001.Popup(X, Y);
  1418. end;
  1420. procedure T_AM2000_MenuDesignerDlg.LoadBitmapFromFileClick(Sender: TObject);
  1421. begin
  1422.   if not OpenPictureDialog1.Execute
  1423.   then Exit;
  1425.   with TMenuItem2000(MenuTree.Selected.Data) do
  1426.     Bitmap.LoadFromFile(OpenPictureDialog1.Filename);
  1428.   if Designer <> nil
  1429.   then Designer.Modified;
  1431.   if ActiveMenuBar <> nil
  1432.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1433. end;
  1435. procedure T_AM2000_MenuDesignerDlg.SaveBitmapToFileClick(Sender: TObject);
  1436. begin
  1437.   if not SavePictureDialog1.Execute
  1438.   then Exit;
  1440.   with TMenuItem2000(MenuTree.Selected.Data) do
  1441.     Bitmap.SaveToFile(SavePictureDialog1.Filename);
  1442. end;
  1444. procedure T_AM2000_MenuDesignerDlg.PopupMenu20001Popup(Sender: TObject);
  1445.   // restore bitmap indexes
  1446. var
  1447.   il: TImageList;
  1448. begin
  1449.   if Assigned(MenuTree.Selected) then
  1450.     with TMenuItem2000(MenuTree.Selected.Data) do begin
  1451.       IgnoreRepaintFloating:= True;
  1452.       ButtonArray1.AsButtonArray.ItemIndex:= DefaultIndex;
  1453.       IgnoreRepaintFloating:= False;
  1454.       None1.AsButton.Down:= (not IsBitmapAssigned);
  1455.     end;
  1457.   // load bitmaps from menu's imagelist
  1458.   il:= nil;
  1459.   if Menu is TMainMenu2000 then il:= TImageList(TCustomMainMenu2000(Menu).Images);
  1460.   if Menu is TPopupMenu2000 then il:= TImageList(TCustomPopupMenu2000(Menu).Images);
  1461.   ImageListBitmaps1.Enabled:= (MenuTree.Selected <> nil)
  1462.     and (MenuTree.Selected.Parent <> nil)
  1463.     and (il <> nil)
  1464.     and (il.Count > 0);
  1465. end;
  1467. procedure T_AM2000_MenuDesignerDlg.None1Click(Sender: TObject);
  1468.   // remove the bitmap
  1469. begin
  1470.   if None1.AsButton.Down then Exit;
  1472.   None1.AsButton.Down:= True;
  1473.   None2.AsButton.Down:= True;
  1474.   with MenuTree.Selected, TMenuItem2000(Data) do begin
  1475.     DefaultIndex:= -1;
  1476.     ImageIndex:= -1;
  1477.     if IsBitmapAssigned then begin
  1478.       Bitmap.Handle:= 0;
  1479.     end;
  1481.     if Designer <> nil then begin
  1482.       Designer.Modified;
  1483.       Designer.SelectComponent(TMenuItem2000(Data));
  1484.     end;
  1486.     if ActiveMenuBar <> nil
  1487.     then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1488.     
  1489.   end;
  1490. end;
  1492. procedure T_AM2000_MenuDesignerDlg.ButtonArray1Click(Sender: TObject);
  1493.   // assigns default bitmaps
  1494. begin
  1495.   with ButtonArray1.AsButtonArray, MenuTree.Selected, TMenuItem2000(Data)
  1496.   do begin
  1497.     DefaultIndex:= ItemIndex;
  1498.     ImageIndex:= -1;
  1499.     None2.AsButton.Down:= False;
  1500.     ButtonArray2.AsButtonArray.ItemIndex:= -1;
  1502.     if Designer <> nil then begin
  1503.       Designer.SelectComponent(TMenuItem2000(Data));
  1504.       Designer.Modified;
  1505.     end;
  1507.     if ActiveMenuBar <> nil
  1508.     then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1509.   end;
  1510. end;
  1512. procedure T_AM2000_MenuDesignerDlg.ButtonArray2Click(Sender: TObject);
  1513.   // assigns imagelist's bitmap
  1514. begin
  1515.   with ButtonArray2.AsButtonArray, MenuTree.Selected, TMenuItem2000(Data)
  1516.   do begin
  1517.     DefaultIndex:= -1;
  1518.     ImageIndex:= ItemIndex;
  1519.     None1.AsButton.Down:= False;
  1520.     ButtonArray1.AsButtonArray.ItemIndex:= -1;
  1522.     if Designer <> nil then begin
  1523.       Designer.SelectComponent(TMenuItem2000(Data));
  1524.       Designer.Modified;
  1525.     end;
  1527.     if ActiveMenuBar <> nil
  1528.     then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1529.   end;
  1530. end;
  1532. procedure T_AM2000_MenuDesignerDlg.SetMenu(const Value: TMenu);
  1534.   procedure AddMenu(M: TMenuItem2000; T: TTreeNodes; N: TTreeNode);
  1535.   var
  1536.     I: Integer;
  1537.     N1: TTreeNode;
  1538.   begin
  1539.     for I:= 0 to M.Count -1 do begin
  1540.       N1:= T.AddChild(N, M[I].Caption);
  1541.       N1.Data:= M[I];
  1542.       TreeNodeList.Add(N1);
  1543.       MenuItemList.Add(N1.Data);
  1544.       if M[I].Count > 0 then AddMenu(M[I], T, N1);
  1545.     end;
  1546.   end;
  1548. var
  1549.   N: TTreeNode;
  1550.   MI: TMenuItem2000;
  1551. begin
  1553.   // updating
  1554.   Updating:= True;
  1555.   MenuTree.Items.BeginUpdate;
  1557.   // init menu tree items
  1558.   MenuTree.Items.Clear;
  1559.   SelectedList.Clear;
  1560.   MenuItemList.Clear;
  1561.   TreeNodeList.Clear;
  1563.   FMenu:= Value;
  1564.   if FMenu = nil then Exit;
  1566.   try
  1567.     MI:= nil;
  1569.     if Menu is TCustomMainMenu2000 then MI:= TCustomMainMenu2000(Menu).Items2000;
  1570.     if Menu is TCustomPopupMenu2000 then MI:= TCustomPopupMenu2000(Menu).Items2000;
  1572.     N:= MenuTree.Items.Add(nil, 'AnimatedMenus/2000');
  1573.     N.Data:= MI;
  1574.     TreeNodeList.Add(N);
  1575.     MenuItemList.Add(N.Data);
  1577.     AddMenu(MI, MenuTree.Items, N);
  1579.     MenuTree.Items[0].Expand(False);
  1580.   except
  1581.   end;
  1583.   MenuTree.Items.EndUpdate;
  1584.   Updating:= False;
  1585.   LastSelected:= nil;
  1586. end;
  1588. procedure T_AM2000_MenuDesignerDlg.AM2000MenuDesigner6Click(
  1589.   Sender: TObject);
  1590. begin
  1591.   // updating
  1592.   Updating:= True;
  1593.   MenuTree.Items.BeginUpdate;
  1594.   MenuTree.FullExpand;
  1595.   MenuTree.Items.EndUpdate;
  1596.   Updating:= False;
  1597. end;
  1599. procedure T_AM2000_MenuDesignerDlg.AM2000MenuDesigner7Click(
  1600.   Sender: TObject);
  1601. begin
  1602.   // updating
  1603.   Updating:= True;
  1604.   MenuTree.Items.BeginUpdate;
  1605.   MenuTree.FullCollapse;
  1606.   MenuTree.Items.EndUpdate;
  1607.   Updating:= False;
  1608. end;
  1610. procedure T_AM2000_MenuDesignerDlg.MenuTree1Editing(Sender: TObject;
  1611.   Node: TTreeNode; var AllowEdit: Boolean);
  1612. begin
  1613.   AllowEdit:= Node.Parent <> nil;
  1614. end;
  1616. procedure T_AM2000_MenuDesignerDlg.ButtonStayOnTopClick(Sender: TObject);
  1617. begin
  1618.   SelectedList.Clear;
  1620.   if ButtonStayOnTop.Down
  1621.   then FormStyle:= fsStayOnTop
  1622.   else FormStyle:= fsNormal;
  1624.   if MenuTree.Items.Count > 0 then
  1625.     MenuTree.Items[0].Expand(False);
  1626. end;
  1628. procedure T_AM2000_MenuDesignerDlg.ImageListMenuPopup(Sender: TObject);
  1629. var
  1630.   il: TImageList;
  1631. begin
  1632.   // load bitmaps from menu's imagelist
  1633.   il:= nil;
  1634.   if Menu is TMainMenu2000 then il:= TImageList(TCustomMainMenu2000(Menu).Images);
  1635.   if Menu is TPopupMenu2000 then il:= TImageList(TCustomPopupMenu2000(Menu).Images);
  1637.   if (il = nil) or (il.Count = 0)
  1638.   then begin
  1639.     ImageListBitmaps1.Enabled:= False;
  1640.     ButtonArray2.AsButtonArray.Bitmap.Width:= 0;
  1641.   end
  1642.   else begin
  1643.     DrawImageList(ButtonArray2, il);
  1644.     ImageListBitmaps1.Enabled:= True;
  1645.   end;
  1646. end;
  1648. procedure T_AM2000_MenuDesignerDlg.FormClose(Sender: TObject;
  1649.   var Action: TCloseAction);
  1650. begin
  1651.   Action:= caFree;
  1652. end;
  1654. procedure T_AM2000_MenuDesignerDlg.wmSelectComponent(var Msg: TMessage);
  1655. begin
  1656.   if Designer <> nil
  1657.   then begin
  1658.     Designer.SelectComponent(TMenuItem2000(Msg.LParam));
  1659.     Designer.Modified;
  1660.   end;
  1661. end;
  1664. procedure T_AM2000_MenuDesignerDlg.DeselectAll1Click(Sender: TObject);
  1665. begin
  1666.   InvalidateList;
  1667.   SelectedList.Clear;
  1668. end;
  1670. procedure T_AM2000_MenuDesignerDlg.UpdateSelections;
  1671. var
  1672.   I: Integer;
  1673. {$IFDEF Delphi5OrHigher}
  1674.   S: TDesignerSelectionList;
  1675. {$ELSE}
  1676.   S: TComponentList;
  1677. {$ENDIF}
  1678. begin
  1679.   if Designer = nil then Exit;
  1681.   if SelectedList.Count > 1
  1682.   then begin
  1683. {$IFDEF Delphi5OrHigher}
  1684.     S:= TDesignerSelectionList.Create;
  1685. {$ELSE}
  1686.     S:= TComponentList.Create;
  1687. {$ENDIF}
  1689.     for I:= 0 to SelectedList.Count -1 do
  1690.       S.Add(TMenuItem2000(TTreeNode(SelectedList[I]).Data));
  1692.     Designer.SetSelections(S);
  1693.     S.Free;
  1694.   end
  1695.   else
  1696.     Designer.SelectComponent(TMenuItem2000(TTreeNode(SelectedList[0]).Data));
  1697. end;
  1699. procedure T_AM2000_MenuDesignerDlg.ClearSelections;
  1700.   // removes selections
  1701. var
  1702.   N: TTreeNode;
  1703.   SL1: TList;
  1704.   I: Integer;
  1706.   function RemoveFromSelList(Node: TTreeNode): Integer;
  1707.     // remove node and its children
  1708.   var
  1709.     I, C: Integer;
  1710.   begin
  1711.     Result:= 0;
  1712.     if (Node = nil) then Exit;
  1713.     C:= SL1.Count;
  1714.     SL1.Remove(Node);
  1716.     I:= 0;
  1717.     while I < SL1.Count -1 do begin
  1718.       if Node.IndexOf(TTreeNode(SL1[I])) <> -1
  1719.       then Dec(I, RemoveFromSelList(TTreeNode(SL1[I])));
  1720.       Inc(I);
  1721.     end;
  1723.     Result:= C - SL1.Count;
  1724.   end;
  1726. begin
  1727.   // updating
  1728.   Updating:= True;
  1729.   MenuTree.Items.BeginUpdate;
  1731.   SL1:= TList.Create;
  1732.   for I:= 0 to SelectedList.Count -1 do
  1733.     SL1.Add(SelectedList[I]);
  1735.   SelectedList.Clear;
  1737.   while SL1.Count > 0 do begin
  1738.     N:= TTreeNode(SL1[0]);
  1739.     RemoveFromSelList(N);
  1740.     TMenuItem2000(N.Data).Free;
  1741.     N.Free;
  1742.   end;
  1744.   SL1.Free;
  1745.   MenuTree.Items.EndUpdate;
  1746.   Updating:= False;
  1747.   CheckConstraints;
  1749.   if Designer <> nil
  1750.   then Designer.Modified;
  1752.   if ActiveMenuBar <> nil
  1753.   then PostMessage(ActiveMenuBar.Handle, wm_UpdateMenuBar, upForceRebuild, 0);
  1754.   
  1755. end;
  1757. procedure T_AM2000_MenuDesignerDlg.CopySelections;
  1758. var
  1759.   S, S2: String;
  1760.   M1, M2: TMemoryStream;
  1761.   I: Integer;
  1762. begin
  1763.   if SelectedList.Count = 0 then Exit;
  1765.   S:= '';
  1766.   M1:= TMemoryStream.Create;
  1767.   M2:= TMemoryStream.Create;
  1769.   for I:= 0 to SelectedList.Count -1 do begin
  1770.     // write menu item into m1
  1771.     M1.WriteComponent(TMenuItem2000(TTreeNode(SelectedList[I]).Data));
  1772.     M1.Seek(0, 0);
  1774.     // ObjectResourceToText
  1775.     ObjectBinaryToText(M1, M2);
  1776.     M2.Seek(0, 0);
  1778.     // convert M2 to S2
  1779.     SetLength(S2, M2.Size);
  1780.     M2.ReadBuffer(PChar(S2)^, M2.Size);
  1782.     // add S2 to S
  1783.     AppendStr(S, S2);
  1784.   end;
  1786.   M1.Free;
  1787.   M2.Free;
  1789.   if S <> '' then CopyToClipboard(S);
  1790.   
  1791. end;
  1793. procedure T_AM2000_MenuDesignerDlg.btnCutClick(Sender: TObject);
  1794. begin
  1795.   CopySelections;
  1796.   ClearSelections;
  1797.   CheckConstraints;
  1798. end;
  1800. procedure T_AM2000_MenuDesignerDlg.btnCopyClick(Sender: TObject);
  1801. begin
  1802.   CopySelections;
  1803.   CheckConstraints;
  1804. end;
  1806. procedure T_AM2000_MenuDesignerDlg.btnPasteClick(Sender: TObject);
  1807. var
  1808.   S: String;
  1809.   M1, M2: TMemoryStream;
  1810.   N, N1: TTreeNode;
  1811.   M, MI1: TMenuItem2000;
  1813.   procedure InsertChildNodes(Node: TTreeNode; Item: TMenuItem);
  1814.   var
  1815.     I: Integer;
  1816.     N: TTreeNode;
  1817.   begin
  1818.     for I:= 0 to Item.Count -1 do begin
  1819.       N:= MenuTree.Items.AddChild(Node, Item[I].Caption);
  1820.       N.Data:= Item[I];
  1821.       TreeNodeList.Add(N);
  1822.       MenuItemList.Add(N.Data);
  1823.       InsertChildNodes(N, Item[I]);
  1824.     end;
  1825.   end;
  1827. begin
  1828.   // selection
  1829.   N:= MenuTree.Selected;
  1830.   if (not Assigned(N))
  1831.   or (not Assigned(N.Parent)) then Exit;
  1833.   // clear selection
  1834.   // updating
  1835.   Updating:= True;
  1836.   MenuTree.Items.BeginUpdate;
  1837.   InvalidateList;
  1838.   SelectedList.Clear;
  1840.   MI1:= nil;
  1841.   M1:= TMemoryStream.Create;
  1842.   M2:= TMemoryStream.Create;
  1844.   try
  1845.     // load component
  1846.     S:= PasteFromClipboard;
  1848.     // store to stream
  1849.     M1.WriteBuffer(PChar(S)^, Length(S));
  1850.     M1.Seek(0, 0);
  1852.     while M1.Position < M1.Size do begin
  1853.       MI1:= TMenuItem2000.Create(Menu.Owner);
  1855.       // convert into component
  1856.       ObjectTextToBinary(M1, M2);
  1857.       M2.Seek(0, 0);
  1859.       // readcomponent
  1860.       M2.ReadComponent(MI1);
  1862.       // insert into menu and tree
  1863.       M:= TMenuItem2000(N.Data);
  1865.       if (N.GetNextSibling <> nil) then begin
  1866.         N1:= MenuTree.Items.Insert(N.GetNextSibling, MI1.Caption);
  1867.         M.Parent.Insert(M.MenuIndex +1, MI1);
  1868.       end
  1869.       else begin
  1870.         N1:= MenuTree.Items.Add(N, MI1.Caption);
  1871.         M.Parent.Add(MI1);
  1872.       end;
  1874.       N1.Data:= MI1;
  1875.       TreeNodeList.Add(N1);
  1876.       MenuItemList.Add(N1.Data);
  1877.       InsertChildNodes(N1, MI1);
  1879.       // select
  1880.       SelectedList.Add(N1);
  1882.       // remove reference
  1883.       MI1:= nil;
  1884.     end;
  1886.   except
  1887.     M1.Free;
  1888.     M2.Free;
  1889.     MI1.Free;
  1890.     MenuTree.Items.EndUpdate;
  1891.     Updating:= False;
  1893.     raise;
  1894.   end;
  1896.   M1.Free;
  1897.   M2.Free;
  1898.   MenuTree.Items.EndUpdate;
  1899.   Updating:= False;
  1900. end;
  1902. procedure T_AM2000_MenuDesignerDlg.SelectAll2Click(Sender: TObject);
  1903. var
  1904.   I: Integer;
  1905. begin
  1906.   SelectedList.Clear;
  1908.   with MenuTree.Items do begin
  1909.     BeginUpdate;
  1911.     for I:= 0 to Count -1 do
  1912.       SelectedList.Add(Item[I]);
  1914.     EndUpdate;
  1915.   end;
  1916. end;
  1918. procedure T_AM2000_MenuDesignerDlg.FormActivate(Sender: TObject);
  1919. begin
  1920.   CheckConstraints;
  1921. end;
  1923. procedure T_AM2000_MenuDesignerDlg.Panel1MouseMove(Sender: TObject;
  1924.   Shift: TShiftState; X, Y: Integer);
  1925. begin
  1926. //  Panel1.ShowHint:= True;
  1927. end;
  1930. { T_AM2000_TreeView4 }
  1932. {$IFNDEF Delphi4OrHigher}
  1934. const
  1935. { =============== GENERIC WM_NOTIFY EVENTS FOR TREEVIEWS ==================== }
  1937.   NM_CUSTOMDRAW            = NM_FIRST-12;
  1938.   NM_HOVER                 = NM_FIRST-13;
  1939.   NM_NCHITTEST             = NM_FIRST-14;   // uses NMMOUSE struct
  1940.   NM_KEYDOWN               = NM_FIRST-15;   // uses NMKEY struct
  1941.   NM_RELEASEDCAPTURE       = NM_FIRST-16;
  1942.   NM_SETCURSOR             = NM_FIRST-17;   // uses NMMOUSE struct
  1943.   NM_CHAR                  = NM_FIRST-18;   // uses NMCHAR struct
  1945. { ==================== CUSTOM DRAW ========================================== }
  1947. const
  1948.   // custom draw return flags
  1949.   // values under 0x00010000 are reserved for global custom draw values.
  1950.   // above that are for specific controls
  1951.   CDRF_DODEFAULT          = $00000000;
  1952.   CDRF_NEWFONT            = $00000002;
  1953.   CDRF_SKIPDEFAULT        = $00000004;
  1955.   CDRF_NOTIFYPOSTPAINT    = $00000010;
  1956.   CDRF_NOTIFYITEMDRAW     = $00000020;
  1957.   CDRF_NOTIFYSUBITEMDRAW  = $00000020;  // flags are the same, we can distinguish by context
  1958.   CDRF_NOTIFYPOSTERASE    = $00000040;
  1960.   // drawstage flags
  1961.   // values under = $00010000 are reserved for global custom draw values.
  1962.   // above that are for specific controls
  1963.   CDDS_PREPAINT           = $00000001;
  1964.   CDDS_POSTPAINT          = $00000002;
  1965.   CDDS_PREERASE           = $00000003;
  1966.   CDDS_POSTERASE          = $00000004;
  1967.   // the = $000010000 bit means it's individual item specific
  1968.   CDDS_ITEM               = $00010000;
  1969.   CDDS_ITEMPREPAINT       = CDDS_ITEM or CDDS_PREPAINT;
  1970.   CDDS_ITEMPOSTPAINT      = CDDS_ITEM or CDDS_POSTPAINT;
  1971.   CDDS_ITEMPREERASE       = CDDS_ITEM or CDDS_PREERASE;
  1972.   CDDS_ITEMPOSTERASE      = CDDS_ITEM or CDDS_POSTERASE;
  1973.   CDDS_SUBITEM            = $00020000;
  1975.   // itemState flags
  1976.   CDIS_SELECTED       = $0001;
  1977.   CDIS_GRAYED         = $0002;
  1978.   CDIS_DISABLED       = $0004;
  1979.   CDIS_CHECKED        = $0008;
  1980.   CDIS_FOCUS          = $0010;
  1981.   CDIS_DEFAULT        = $0020;
  1982.   CDIS_HOT            = $0040;
  1983.   CDIS_MARKED         = $0080;
  1984.   CDIS_INDETERMINATE  = $0100;
  1987. type
  1988.   tagNMCUSTOMDRAWINFO = packed record
  1989.     hdr: TNMHdr;
  1990.     dwDrawStage: DWORD;
  1991.     hdc: HDC;
  1992.     rc: TRect;
  1993.     dwItemSpec: DWORD;  // this is control specific, but it's how to specify an item.  valid only with CDDS_ITEM bit set
  1994.     uItemState: UINT;
  1995.     lItemlParam: LPARAM;
  1996.   end;
  1997.   PNMCustomDraw = ^TNMCustomDraw;
  1998.   TNMCustomDraw = tagNMCUSTOMDRAWINFO;
  2000.   tagNMTTCUSTOMDRAW = packed record
  2001.     nmcd: TNMCustomDraw;
  2002.     uDrawFlags: UINT;
  2003.   end;
  2004.   PNMTTCustomDraw = ^TNMTTCustomDraw;
  2005.   TNMTTCustomDraw = tagNMTTCUSTOMDRAW;
  2007.   tagNMTVCUSTOMDRAW = packed record
  2008.     nmcd: TNMCustomDraw;
  2009.     clrText: COLORREF;
  2010.     clrTextBk: COLORREF;
  2011.     iLevel: Integer;
  2012.   end;
  2013.   PNMTVCustomDraw = ^TNMTVCustomDraw;
  2014.   TNMTVCustomDraw = tagNMTVCUSTOMDRAW;
  2016. {$ENDIF}
  2019. constructor T_AM2000_TreeView4.Create(AOwner: TComponent);
  2020. begin
  2021.   inherited Create(AOwner);
  2022.   FCanvas:= TControlCanvas.Create;
  2023.   TControlCanvas(FCanvas).Control:= Self;
  2024. end;
  2026. destructor T_AM2000_TreeView4.Destroy;
  2027. begin
  2028.   FCanvas.Free;
  2029.   inherited Destroy;
  2030. end;
  2032. procedure T_AM2000_TreeView4.CreateParams(var Params: TCreateParams);
  2033. const
  2034.   TVS_NOTOOLTIPS  = $0080;
  2035. begin
  2036.   inherited;
  2037.   with Params do Style:= Style or TVS_NOTOOLTIPS;
  2038. end;
  2040. function T_AM2000_TreeView4.GetNodeFromItem(const Item: TTVItem): TTreeNode;
  2041. begin
  2042.   with Item do
  2043.     if (state and TVIF_PARAM) <> 0 then Result:= Pointer(lParam)
  2044.     else Result:= Items.GetNode(hItem);
  2045. end;
  2047. procedure T_AM2000_TreeView4.CNNotify(var Message: TWMNotify);
  2048. var
  2049.   Node: TTreeNode;
  2050.   TmpItem: TTVItem;
  2051. {$IFDEF Delphi5OrHigher}
  2052.   PaintImages: Boolean;
  2053. {$ENDIF}
  2054. begin
  2055.   with Message do
  2056.     case NMHdr^.code of
  2057.       NM_CUSTOMDRAW:
  2058.         with PNMCustomDraw(NMHdr)^ do
  2059.         begin
  2060.           Result:= CDRF_DODEFAULT;
  2061.           if dwDrawStage = CDDS_PREPAINT then
  2062.           begin
  2063.             Result:= Result or CDRF_NOTIFYITEMDRAW
  2064.           end
  2065.           else if dwDrawStage = CDDS_ITEMPREPAINT then
  2066.           begin
  2067.             FillChar(TmpItem, SizeOf(TmpItem), 0);
  2068.             TmpItem.hItem:= HTREEITEM(dwItemSpec);
  2069.             Node:= GetNodeFromItem(TmpItem);
  2070.             if Node <> nil then
  2071.             begin
  2072.               FCanvas.Handle:= hdc;
  2073.               FCanvas.Font:= Font;
  2074.               FCanvas.Brush:= Brush;
  2075.               FCanvas.Font.OnChange:= CanvasChanged;
  2076.               FCanvas.Brush.OnChange:= CanvasChanged;
  2077.               CustomDrawItem(Node,
  2078.                 TCustomDrawState(Word(uItemState)), cdPrePaint
  2079. {$IFDEF Delphi5OrHigher}
  2080. ,               PaintImages
  2081. {$ENDIF}
  2082.                 );
  2083.               Result:= Result or CDRF_SKIPDEFAULT;
  2084.               FCanvas.Handle:= 0;
  2085.               if IsCustomDrawn(dtItem, cdPostPaint) then
  2086.                 Result:= Result or CDRF_NOTIFYPOSTPAINT;
  2087.             end;
  2088.           end;
  2089.         end;
  2090.       else
  2091.         inherited;
  2092.     end;
  2093. end;
  2095. procedure T_AM2000_TreeView4.CanvasChanged;
  2096. begin
  2097.   FCanvasChanged:= True;
  2098. end;
  2100. function T_AM2000_TreeView4.IsCustomDrawn(Target: TCustomDrawTarget; Stage: TCustomDrawStage): Boolean;
  2101. begin
  2102.   if Stage = cdPrePaint
  2103.   then
  2104.     if Target = dtItem
  2105.     then Result:= Assigned(FOnCustomDrawItem)
  2106.     else Result:= False
  2108.   else
  2109.     Result:= False;
  2110. end;
  2112. function T_AM2000_TreeView4.CustomDrawItem(Node: TTreeNode; State: TCustomDrawState;
  2113.   Stage: TCustomDrawStage
  2114. {$IFDEF Delphi5OrHigher}
  2115. ;  var PaintImages: Boolean
  2116. {$ENDIF}
  2117.   ): Boolean;
  2118. begin
  2119.   Result:= True;
  2120.   if Assigned(FOnCustomDrawItem) then FOnCustomDrawItem(Self, Node, State, Result);
  2121. {$IFDEF Delphi5OrHigher}
  2122.   PaintImages:= False;
  2123. {$ENDIF}
  2124. end;
  2126. procedure T_AM2000_MenuDesignerDlg.ShortCuts1Click(Sender: TObject);
  2127. {$IFDEF Delphi3OrHigher}
  2128. var
  2129.   ShortCutEditor: T_AM2000_ShortCutEditor;
  2130.   S: String;
  2131.   mi: TMenuItem2000;
  2132. {$ENDIF}
  2133. begin
  2134. {$IFDEF Delphi3OrHigher}
  2135.   if (MenuTree.Selected = nil)
  2136.   and (SelectedList.Count = 0)
  2137.   then Exit;
  2139.   if (MenuTree.Selected <> nil)
  2140.   then mi:= TMenuItem2000(MenuTree.Selected.Data)
  2141.   else mi:= TMenuItem2000(SelectedList[0]);
  2143.   ShortCutEditor:= T_AM2000_ShortCutEditor.Create(Self);
  2145.   S:= mi.ShortCut;
  2146.   if ShortCutEditor.EditShortCuts(S) then begin
  2147.     mi.ShortCut:= S;
  2148.     if Designer <> nil then begin
  2149.       Designer.Modified;
  2150.       Designer.SelectComponent(mi);
  2151.     end;
  2152.   end;
  2154.   ShortCutEditor.Free;
  2155. {$ENDIF}
  2156. end;
  2158. end.