gikonavigoeson/gikonavi/InputAssistDataModule.pas

unit InputAssistDataModule;

interface

uses
  SysUtils, Classes, Windows;

type
  TResistWord = class;

  TInputAssistDM = class(TDataModule)
    procedure DataModuleDestroy(Sender: TObject);
    procedure DataModuleCreate(Sender: TObject);
  private
        { Private ?辿?転 }
        FInit : Boolean;
        FDictionary : TStringList;      ///< ?o?^?P???????^?????鼎??
        FSorted : Boolean;
        function GetSorted: Boolean;    ///< ?\?[?g???坦???????転
        procedure SetSorted(Value: Boolean);    ///< ?\?[?g?坦????????

  public
        { Public ?辿?転 }
        property Sorted : Boolean read GetSorted write SetSorted;
        procedure Init(FilePath: String);
        procedure SaveToFile(FilePath: String);
        function ResistWordCount : Integer;     ///<?o?^?P???????転
        function GetResistWord(Index: Integer): TResistWord;    ///< ?o?^?P?????転
        procedure DeleteResistWord(ResistWord: TResistWord);  ///< ?o?^?P?????鱈??
        function Add(Key: String): TResistWord; ///< ?o?^?P??????
        procedure ChangeKey(ResistWord: TResistWord);  ///< ?o?^?P?????L?[???X
        //! Key???L?[???????o?^?????????辿?P???????転
        function GetStartWithKeyResistWords(Key: String; var list: TStringList): Integer;
        //! Key???J?e?S?????????o?^?????????辿?P???????転
        function GetStartWithCategoryResistWords(Key: String; var list: TStringList): Integer;
        //! Key???J?e?S?????o?^?????????辿?P???????転
        function GetCategoryResistWords(Key: String; var list: TStringList): Integer;
        //! ?o?^?????L?[???S?????J?e?S?????X?g???転
        procedure GetCategoryList(var list: TStringList);
        //! ?哲???o?^???????L?[???J?e?S?????Z?b?g?????造???`?F?b?N
        function IsDupulicate(Key: String; Category: String): Boolean;

  end;

  TResistWord = class(TObject)
  private
        FKey : String;          ///< ?????????L?[?????辿
        FCategory : String;     ///< ???鄭
        FText : String;         ///< ???^??
  public
        function GetKey: String;
        procedure SetKey(Value: String);
        function GetCategory: String;
        procedure SetCategory(Value: String);
        function GetText: String;
        procedure SetText(Value: String);
        property Key: String read FKey write FKey;
        property Category: String read FCategory write FCategory;
        property Text: String read GetText write SetText;
  end;

  function CategorySort(List: TStringList; Index1, Index2: Integer): Integer;
  function KeySort(List: TStringList; Index1, Index2: Integer): Integer;
var
  InputAssistDM: TInputAssistDM;

implementation

uses
  MojuUtils, IniFiles;

{$R *.dfm}
//! FKey???????????????辿?l?????転???辿
function TResistWord.GetKey: String;
begin
        //?G?X?P?[?v?直?????辿=?????????辿
        Result := MojuUtils.CustomStringReplace(FKey, '&#61;', '=');
end;
//! FKey???l?????????辿
procedure TResistWord.SetKey(Value: String);
begin
        //=???徹???????g?造???長?G?X?P?[?v???辿
        FKey := MojuUtils.CustomStringReplace(Value, '=', '&#61;');
end;
//! FCategory???????????????辿?l?????転???辿
function TResistWord.GetCategory: String;
begin
        //?G?X?P?[?v?直?????辿=?????????辿
        Result := MojuUtils.CustomStringReplace(FCategory, '&#61;', '=');
end;
//! FCategory???l?????????辿
procedure TResistWord.SetCategory(Value: String);
begin
        //=???徹???????g?造???長?G?X?P?[?v???辿
        FCategory := MojuUtils.CustomStringReplace(Value, '=', '&#61;');
end;
//! FText???????????????辿?l?????転???辿
function TResistWord.GetText: String;
begin
        //?G?X?P?[?v?直?????辿=?????????辿
        Result := MojuUtils.CustomStringReplace(FText, '&#61;', '=');
        // #1???直???端?s?R?[?h??#13#10?????????辿
        Result := MojuUtils.CustomStringReplace(Result, #1, #13#10);
end;
procedure TResistWord.SetText(Value: String);
begin
        //=???徹???????g?造???長?G?X?P?[?v???辿
        FText := MojuUtils.CustomStringReplace(Value, '=', '&#61;');
        //?端?s?R?[?h??#1?????辿?i1?s?????辿????)
        FText := MojuUtils.CustomStringReplace(FText, #13#10, #1);
end;
//! ?t?@?C?????????????長???炭?泥???辿
procedure TInputAssistDM.Init(FilePath: String);
var
        ini : TMemIniFile;
        sections: TStringList;
        keys: TStringList;
        i, j : Integer;
        resWord : TResistWord;
begin
        FInit := True;
        try
                // ?t?@?C???????????m?F
                if FileExists(FilePath) then begin
            ini := TMemIniFile.Create(FilePath);
                        sections := TStringList.Create;
                        keys := TStringList.Create;
                        try
                                ini.ReadSections(sections);

                                for i :=0 to sections.Count - 1 do begin
                                        keys.Clear;
                                        ini.ReadSection(sections[i], keys);
                                        for j := 0 to keys.Count - 1 do begin
                                                resWord := TResistWord.Create;
                                                resWord.SetCategory(sections[i]);
                                                resWord.SetKey(keys[j]);
                                                resWord.SetText(ini.ReadString(sections[i], keys[j], ''));
                                                FDictionary.AddObject(resWord.GetKey, resWord);
                                        end;
                                end;
                        finally
                                keys.Free;
                                sections.Free;
                                ini.Free;
                        end;
                        if FSorted Then begin
                                FDictionary.CustomSort(KeySort);
                        end;
                end;

        except
                FInit := False;
        end;
end;
//! ?w?????????p?X???t?@?C?????徹?????辿
procedure TInputAssistDM.SaveToFile(FilePath: String);
var
        ini : TMemIniFile;
        i : Integer;
        resWord : TResistWord;
begin
        if FileExists(FilePath) then begin
                try
                        SysUtils.DeleteFile(FilePath);
                except
                end;
        end;

        ini := TMemIniFile.Create(FilePath);
        try
                for i :=0 to FDictionary.Count - 1 do begin
                        resWord := TResistWord(FDictionary.Objects[i]);
                        ini.WriteString(resWord.FCategory, resWord.FKey, resWord.FText);
                end;
                ini.UpdateFile;
        finally
                ini.Free;
        end;
end;
//! ?f?X?g???N?^
procedure TInputAssistDM.DataModuleDestroy(Sender: TObject);
var
        i : Integer;
begin
        if (FDictionary <> nil) then begin
                for i := FDictionary.Count - 1 downto 0 do begin
                        TResistWord(FDictionary.Objects[i]).Free;
                end;
                FDictionary.Clear;
                FDictionary.Capacity := 0;
                FDictionary.Free;
        end;
end;
//! ?R???X?g???N?^
procedure TInputAssistDM.DataModuleCreate(Sender: TObject);
begin
        FDictionary := TStringList.Create;
        FDictionary.Sorted := False;
        FSorted := True;
end;
//! ?o?^?P???????転
function TInputAssistDM.ResistWordCount : Integer;
begin
        Result := 0;
        if (FDictionary <> nil) then begin
                Result := FDictionary.Count;
        end;
end;
//! ?o?^?P?????転
function TInputAssistDM.GetResistWord(Index: Integer): TResistWord;
begin
        Result := nil;
        if (FDictionary <> nil) then begin
                if (Index >= 0) and (Index < FDictionary.Count) then begin
                        Result := TResistWord(FDictionary.Objects[index]);
                end;
        end;
end;
//! ?o?^?P?????鱈??
procedure TInputAssistDM.DeleteResistWord(ResistWord: TResistWord);
var
        i : Integer;
begin
        if (FDictionary <> nil) then begin
                for i := 0 to FDictionary.Count - 1 do begin
                        if (ResistWord = FDictionary.Objects[i]) then begin
                                TResistWord(FDictionary.Objects[i]).Free;
                                FDictionary.Delete(i);
                                break;
                        end;
                end;
                if FSorted Then begin
                        FDictionary.CustomSort(KeySort);
                end;
        end;
end;
//! ?o?^?P??????
function TInputAssistDM.Add(Key: String): TResistWord;
var
        resWord : TResistWord;
begin
        Result := nil;
        if (FDictionary <> nil) then begin
                resWord := TResistWord.Create;
                resWord.SetKey(Key);
                resWord.SetCategory('?J?e?S??');
                resWord.SetText('???^??');
                FDictionary.AddObject(Key, resWord);
                Result := resWord;
                if FSorted Then begin
                        FDictionary.CustomSort(KeySort);
                end;
        end;
end;
//! ?o?^?P?????L?[???X
procedure TInputAssistDM.ChangeKey(ResistWord: TResistWord);
var
        i : Integer;
begin
        if (FDictionary <> nil) then begin
                for i := 0 to FDictionary.Count - 1 do begin
                        if (ResistWord = FDictionary.Objects[i]) then begin
                                FDictionary.Strings[i] := ResistWord.GetKey;
                                break;
                        end;
                end;
                if FSorted Then begin
                        FDictionary.CustomSort(KeySort);
                end;

        end;
end;
//! Key???????o?^?????????辿?P???????転
function TInputAssistDM.GetStartWithKeyResistWords(Key: String; var list: TStringList): Integer;
var
        i : Integer;
        resWord : TResistWord;

begin
        Result := 0;
        if (FDictionary <> nil) and (list <> nil) then begin
                Key := ZenToHan(Key);
                for i := 0 to FDictionary.Count - 1 do begin
                        if (AnsiPos(Key, ZenToHan(FDictionary.Strings[i])) = 1) then begin
                                Inc(Result);
                                resWord := TResistWord(FDictionary.Objects[i]);
                                list.AddObject(resWord.GetKey + '(' +
                                                                resWord.GetCategory + ')', resWord);
                        end else if (Result > 0) then begin
                                //?\?[?g?????????辿???巽?A?q?b?g???????A?????辿???存
                                break;
                        end;
                end;
        end;
end;
//! Key???J?e?S?????????o?^?????????辿?P???????転
function TInputAssistDM.GetStartWithCategoryResistWords(Key: String; var list: TStringList): Integer;
var
        i : Integer;
        resWord : TResistWord;
begin
        Result := 0;
        if (FDictionary <> nil) and (list <> nil) then begin
                Key := ZenToHan(Key);
                for i := 0 to FDictionary.Count - 1 do begin
                        resWord := TResistWord(FDictionary.Objects[i]);
                        if (AnsiPos(Key, ZenToHan(resWord.GetCategory)) = 1) then begin
                                Inc(Result);
                                list.AddObject(resWord.GetKey + '(' +
                                                                resWord.GetCategory + ')', resWord);
                        end;
                end;
                list.CustomSort(CategorySort);
        end;
end;

//! ?\?[?g???坦???????転
function TInputAssistDM.GetSorted: Boolean;
begin
        Result := FSorted;
end;
//! ?\?[?g?坦????????
procedure TInputAssistDM.SetSorted(Value: Boolean);
begin
        if (not FSorted) and (Value) then begin
                FDictionary.CustomSort(KeySort);
        end;
        FSorted := Value;
end;
//! Key???J?e?S?????o?^?????????辿?P???????転
function TInputAssistDM.GetCategoryResistWords(Key: String; var list: TStringList): Integer;
var
        i : Integer;
        resWord : TResistWord;
begin
        Result := 0;
        if (FDictionary <> nil) and (list <> nil) then begin
                for i := 0 to FDictionary.Count - 1 do begin
                        resWord := TResistWord(FDictionary.Objects[i]);
                        if (Key = resWord.GetCategory) then begin
                                Inc(Result);
                                list.AddObject(resWord.GetKey + '(' +
                                                                resWord.GetCategory + ')', resWord);
                        end;
                end;
                list.CustomSort(CategorySort);
        end;
end;

//! ?o?^?????L?[???S?????J?e?S?????X?g???転
procedure TInputAssistDM.GetCategoryList(var list: TStringList);
var
        i : Integer;
begin
        if (FDictionary <> nil) and (list <> nil) then begin
                // ?d???`?F?b?N??TStringList???@?\?長?s?造
                list.Clear;
                list.Duplicates := dupIgnore;
                list.Sorted := true;
                list.BeginUpdate;
                for i := 0 to FDictionary.Count - 1 do begin
                        list.Add(TResistWord(FDictionary.Objects[i]).GetCategory);
                end;
                list.EndUpdate;
        end;
end;

//! Key???J?e?S?????????o?^?P?????????????\?[?g?p?辰?r???\?b?h
function CategorySort(List: TStringList; Index1, Index2: Integer): Integer;
var
        resWord1 : TResistWord;
        resWord2 : TResistWord;
begin
        Result := 0;
        try
                resWord1 := TResistWord(List.Objects[Index1]);
                resWord2 := TResistWord(List.Objects[Index2]);
                Result := CompareStr(ZenToHan(resWord1.GetCategory),
                                                                 ZenToHan(resWord2.GetCategory));
                if (Result = 0) then begin
                        Result := CompareStr(ZenToHan(resWord1.GetKey),
                                                                         ZenToHan(resWord2.GetKey));
                end;
        except
        end;
end;
//! Key???S?添?p???????`?長?\?[?g???辿?徹???辰?r???\?b?h
function KeySort(List: TStringList; Index1, Index2: Integer): Integer;
var
        resWord1 : TResistWord;
        resWord2 : TResistWord;
begin
        Result := 0;
        try
                resWord1 := TResistWord(List.Objects[Index1]);
                resWord2 := TResistWord(List.Objects[Index2]);
                Result := CompareStr(ZenToHan(resWord1.FKey),
                                                                 ZenToHan(resWord2.FKey));
                if (Result = 0) then begin
                        Result := CompareStr(ZenToHan(resWord1.GetCategory),
                                                                         ZenToHan(resWord2.GetCategory));
                end;
        except
        end;
end;
//! ?哲???o?^???????L?[???J?e?S?????Z?b?g?????造???`?F?b?N
function TInputAssistDM.IsDupulicate(Key: String; Category: String): Boolean;
var
        i : Integer;
begin
        // ???????\?b?h?長???A?\?[?g???????????巽???????長?A?S?????L?[???T???直?????辿
        Result := False;
        if (FDictionary <> nil) then begin
                for i := 0 to FDictionary.Count - 1 do begin
                        if (Key = FDictionary.Strings[i]) and
                                (Category = TResistWord(FDictionary.Objects[i]).GetCategory)
                        then begin
                                Result := True;
                                Break;
                        end;
                end;
        end;
end;

end.