gikonavigoeson/gikonavi/GikoSystem.pas

unit GikoSystem;

interface

uses
        Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
        ComCtrls, {IniFiles,} ShellAPI, ActnList, Math,
{$IF Defined(DELPRO) }
        SHDocVw,
        MSHTML,
{$ELSE}
        SHDocVw_TLB,
        MSHTML_TLB,
{$IFEND}
        {HttpApp,} URLMon, IdGlobal, IdURI, {Masks,}
        Setting, BoardGroup, gzip, Dolib, bmRegExp, AbonUnit,
        ExternalBoardManager, ExternalBoardPlugInMain,
        GikoBayesian, GikoMessage, Belib;

type
        TVerResourceKey = (
                        vrComments,         //!< 繧ｳ繝｡繝ｳ繝?/span>
                        vrCompanyName,      //!< 莨夂､ｾ蜷?/span>
                        vrFileDescription,  //!< 隱ｬ譏?/span>
                        vrFileVersion,      //!< 繝輔ぃ繧､繝ｫ繝舌?繧ｸ繝ｧ繝ｳ
                        vrInternalName,     //!< 蜀?Κ蜷?/span>
                        vrLegalCopyright,   //!< 闡嶺ｽ懈ｨｩ
                        vrLegalTrademarks,  //!< 蝠?ｨ?/span>
                        vrOriginalFilename, //!< 豁｣蠑上ヵ繧｡繧､繝ｫ蜷?/span>
                        vrPrivateBuild,     //!< 繝励Λ繧､繝吶?繝医ン繝ｫ繝画ュ蝣ｱ
                        vrProductName,      //!< 陬ｽ蜩∝錐
                        vrProductVersion,   //!< 陬ｽ蜩√ヰ繝ｼ繧ｸ繝ｧ繝ｳ
                        vrSpecialBuild);    //!< 繧ｹ繝壹す繝｣繝ｫ繝薙Ν繝画ュ蝣ｱ

        //! BBS繧ｿ繧､繝?/span>
        TGikoBBSType = (gbt2ch);
        //! 繝ｭ繧ｰ繧ｿ繧､繝?/span>
        TGikoLogType = (glt2chNew, glt2chOld);
        //! 繝｡繝?そ繝ｼ繧ｸ繧｢繧､繧ｳ繝ｳ
        TGikoMessageIcon = (gmiOK, gmiSAD, gmiNG, gmiWhat, gmiNone);
        //! URL繧ｪ繝ｼ繝励Φ繝悶Λ繧ｦ繧ｶ繧ｿ繧､繝?/span>
        TGikoBrowserType = (gbtIE, gbtUserApp, gbtAuto);


        TStrTokSeparator = set of Char;
        TStrTokRec = record
                Str: string;
                Pos: Integer;
        end;

        //! 繧､繝ｳ繝?ャ繧ｯ繧ｹ繝輔ぃ繧､繝ｫ繝ｬ繧ｳ繝ｼ繝?/span>
        TIndexRec = record
                FNo: Integer;
                FFileName: string;
                FTitle: string;
                FCount: Integer;
                FSize: Integer;
//              FRoundNo: Integer;
                FRoundDate: TDateTime;
                FLastModified: TDateTime;
                FKokomade: Integer;
                FNewReceive: Integer;
                FMishiyou: Boolean;     //!< 譛ｪ菴ｿ逕ｨ
                FUnRead: Boolean;
                FScrollTop: Integer;
                //Index Ver 1.01
                FAllResCount: Integer;
                FNewResCount: Integer;
                FAgeSage: TGikoAgeSage;
        end;

        //! 繧ｵ繝悶ず繧ｧ繧ｯ繝医Ξ繧ｳ繝ｼ繝?/span>
        TSubjectRec = record
                FFileName: string;
                FTitle: string;
                FCount: Integer;
        end;

        //! 繝ｬ繧ｹ繝ｬ繧ｳ繝ｼ繝峨∈縺ｮ繝昴う繝ｳ繧ｿ
        PResRec = ^TResRec;

        //! 繝ｬ繧ｹ繝ｬ繧ｳ繝ｼ繝?/span>
        TResRec = record
                FTitle: string;
                FMailTo: string;
                FName: string;
                FDateTime: string;
                FBody: string;
                FType: TGikoLogType;
        end;

        //! URLPath繝ｬ繧ｳ繝ｼ繝?/span>
        TPathRec = record
                FBBS: string;                           //!< BBSID
                FKey: string;                           //!< ThreadID
                FSt: Int64;                               //!< 髢句ｧ九Ξ繧ｹ逡ｪ
                FTo: Int64;                               //!< 邨ゆｺ?Ξ繧ｹ逡ｪ
                FFirst: Boolean;                //!< >>1縺ｮ陦ｨ遉ｺ
                FStBegin: Boolean;      //!< 1縲懆｡ｨ遉ｺ
                FToEnd: Boolean;                //!< 縲懈怙蠕後∪縺ｧ陦ｨ遉ｺ
                FDone: Boolean;                 //!< 謌仙粥
                FNoParam: Boolean;  //!< 繝ｬ繧ｹ逡ｪ繝代Λ繝｡繝ｼ繧ｿ縺ｪ縺?/span>
        end;

        TGikoSys = class(TObject)
        private
                { Private 螳｣險? }
                FSetting: TSetting;
                FDolib: TDolib;
                FAWKStr: TAWKStr;
                FResRange : Longint;
                FBayesian       : TGikoBayesian;        //!< 繝吶う繧ｸ繧｢繝ｳ繝輔ぅ繝ｫ繧ｿ
                FVersion : String;                    //!< 繝輔ぃ繧､繝ｫ繝舌?繧ｸ繝ｧ繝ｳ
                FGikoMessage: TGikoMessage;
        FBelib: TBelib;
                //! 縺ゅｋ繧ｻ繝代Ξ繝ｼ繧ｿ縺ｧ蛹ｺ蛻?ｉ繧後◆譁?ｭ怜?縺九ｉ?守分逶ｮ縺ｮ譁?ｭ怜?繧貞叙繧雁?縺?/span>
                function ChooseString(const Text, Separator: string; Index: integer): string;
        //! 荳?譎ゅヵ繧｡繧､繝ｫ縺九ｉ縺ｮ蠕ｩ譌ｧ
        procedure RestoreThreadData(Board: TBoard);
        public
                { Public 螳｣險? }
                FAbon : TAbon;
                FSelectResFilter : TAbon;
                //FBoardURLList: TStringList;
                constructor Create;

                destructor Destroy; override;
                property ResRange : Longint read FResRange write FResRange;
                //! 繝舌?繧ｸ繝ｧ繝ｳ諠??ｱ
                property Version : String read FVersion;
                function IsNumeric(s: string): boolean;
                function IsFloat(s: string): boolean;
                function DirectoryExistsEx(const Name: string): Boolean;
                function ForceDirectoriesEx(Dir: string): Boolean;

                function GetBoardFileName: string;
                function GetCustomBoardFileName: string;
                function GetHtmlTempFileName: string;
                function GetAppDir: string;
                function GetTempFolder: string;
                function GetSentFileName: string;
                function GetConfigDir: string;
                function GetSkinDir: string;
                function GetSkinHeaderFileName: string;
                function GetSkinFooterFileName: string;
                function GetSkinResFileName: string;
                function GetSkinNewResFileName: string;
                function GetSkinBookmarkFileName: string;
                function GetSkinNewmarkFileName: string;
                function GetStyleSheetDir: string;
                function GetOutBoxFileName: string;
                function GetUserAgent: string;
                                function GetSambaFileName : string;

                function GetMainKeyFileName : String;
                function GetEditorKeyFileName: String;
                function GetInputAssistFileName: String;
                procedure ReadSubjectFile(Board: TBoard);
                procedure CreateThreadDat(Board: TBoard);
                procedure WriteThreadDat(Board: TBoard);
                function ParseIndexLine(Line: string): TIndexRec;
                procedure GetFileList(Path: string; Mask: string; var List: TStringList; SubDir: Boolean; IsPathAdd: Boolean); overload;
                procedure GetFileList(Path: string; Mask: string; var List: TStringList; IsPathAdd: Boolean); overload;//繧ｵ繝悶ヵ繧ｩ繝ｫ繝?縺ｯ讀懃ｴ｢縺励↑縺?/span>
                procedure GetDirectoryList(Path: string; Mask: string; List: TStringList; SubDir: Boolean);

                function DivideSubject(Line: string): TSubjectRec;
                property Setting: TSetting read FSetting write FSetting;
                property Dolib: TDolib read FDolib write FDolib;
                property Belib: TBelib read FBelib write FBelib;

                function UrlToID(url: string): string;
                function UrlToServer(url: string): string;

                function StrTokFirst(const s:string; const sep:TStrTokSeparator; var Rec:TStrTokRec):string;
                function StrTokNext(const sep:TStrTokSeparator; var Rec:TStrTokRec): string;

                function GetFileSize(FileName : string) : longint;
                function GetFileLineCount(FileName : string): longint;
                function IntToDateTime(val: Int64): TDateTime;
                function DateTimeToInt(ADate: TDateTime): Int64;

                function ReadThreadFile(FileName: string; Line: Integer): string;

                procedure MenuFont(Font: TFont);

//              function RemoveToken(var s:string; const delimiter:string):string;
                function GetTokenIndex(s: string; delimiter: string; index: Integer): string;

                function GetShortName(const LongName: string; ALength: integer): string;
                function BoolToInt(b: Boolean): Integer;
                function IntToBool(i: Integer): Boolean;
                function GzipDecompress(ResStream: TStream; ContentEncoding: string): string;
                procedure LoadKeySetting(ActionList: TActionList; FileName: String);
                procedure SaveKeySetting(ActionList: TActionList; FileName: String);
                procedure CreateProcess(const AppPath: string; const Param: string);
                procedure OpenBrowser(URL: string; BrowserType: TGikoBrowserType);
                function HTMLDecode(const AStr: String): String;
                function GetHRefText(s: string): string;
                function Is2chHost(Host: string): Boolean;
                function Parse2chURL(const url: string; const path: string; const document: string; var BBSID: string; var BBSKey: string): Boolean;
                function Parse2chURL2(URL: string): TPathRec;
                procedure ParseURI(const URL : string; var Protocol, Host, Path, Document, Port, Bookmark: string);
                function GetVersionBuild: Integer;
                function        GetBrowsableThreadURL( inURL : string ) : string;
                function        GetThreadURL2BoardURL( inURL : string ) : string;
                function        Get2chThreadURL2BoardURL( inURL : string ) : string;
                function        Get2chBrowsableThreadURL( inURL : string ) : string;
                function        Get2chBoard2ThreadURL( inBoard : TBoard; inKey : string ) : string;
                procedure ListBoardFile;
                procedure ReadBoardFile( bbs : TBBS );

                function        GetUnknownCategory : TCategory;
                function        GetUnknownBoard( inPlugIn : TBoardPlugIn; inURL : string ) : TBoard;

                procedure GetPopupResNumber(URL : string; var stRes, endRes : Int64);

                property Bayesian : TGikoBayesian read FBayesian write FBayesian;
        function CreateResAnchor(var Numbers: TStringList; ThreadItem: TThreadItem; limited: Integer):string;
                procedure GetSameIDRes(const AID : string; ThreadItem: TThreadItem;var body: TStringList); overload;
                procedure GetSameIDRes(AIDNum : Integer; ThreadItem: TThreadItem;var body: TStringList); overload;
        function GetResID(AIDNum: Integer; ThreadItem: TThreadItem): String;
        function ExtructResID(ADateStr: String): String;
                //! 蜊倩ｪ櫁ｧ｣譫?/span>
                procedure SpamCountWord( const text : string; wordCount : TWordCount );
                //! 蟄ｦ鄙偵け繝ｪ繧｢
                procedure SpamForget( wordCount : TWordCount; isSpam : Boolean );
                //! 繧ｹ繝代Β蟄ｦ鄙?/span>
                procedure SpamLearn( wordCount : TWordCount; isSpam : Boolean );
                //! 繧ｹ繝代Β蠎ｦ謨ｰ
                function SpamParse( const text : string; wordCount : TWordCount ) : Extended;

                //! 蠑墓焚縺ｫ騾√ｉ繧後※縺阪◆譌･莉?ID驛ｨ縺ｫBE縺ｮ譁?ｭ怜?縺後≠縺｣縺溘ｉ縲√?繝ｭ繝輔ぃ繧､繝ｫ縺ｸ縺ｮ繝ｪ繝ｳ繧ｯ繧定ｿｽ蜉?
                function AddBeProfileLink(AID : string; ANum: Integer): string;
                //! 繝舌?繧ｸ繝ｧ繝ｳ諠??ｱ縺ｮ蜿門ｾ?/span>
                function GetVersionInfo(KeyWord: TVerResourceKey): string;
                //! Plugin縺ｮ諠??ｱ縺ｮ蜿門ｾ?/span>
                function GetPluginsInfo(): string;
                //! IE縺ｮ繝舌?繧ｸ繝ｧ繝ｳ諠??ｱ縺ｮ蜿門ｾ?/span>
                function GetIEVersion: string;
                function SetUserOptionalStyle(): string;
                //! 繧ｮ繧ｳ繝翫ン縺ｮ繝｡繝?そ繝ｼ繧ｸ繧定ｨｭ螳壹☆繧?/span>
                procedure SetGikoMessage;
                //! 繧ｮ繧ｳ繝翫ン縺ｮ繝｡繝?そ繝ｼ繧ｸ繧貞叙蠕励☆繧?/span>
                function GetGikoMessage(MesType: TGikoMessageListType): String;
                //! GMT縺ｮ譎ょ綾繧探DateTime縺ｫ螟画鋤縺吶ｋ
                function  DateStrToDateTime(const DateStr: string): TDateTime;
        //! User32.dll縺悟茜逕ｨ縺ｧ縺阪ｋ縺?/span>
        function CanUser32DLL: Boolean;
        //! OE蠑慕畑隨ｦ蜿門ｾ?/span>
        function GetOEIndentChar : string;
        //! 鄂ｮ謠幄ｨｭ螳壹ヵ繧｡繧､繝ｫ蜿門ｾ?/span>
        function GetReplaceFileName: String;
        //! 繧､繝ｳ繝?ャ繧ｯ繧ｹ縺ｫ縺ｪ縺?at?医?縺舌ｌdat?峨?霑ｽ蜉?
        procedure AddOutofIndexDat(Board: TBoard; DatList: TStringList; AllCreate: boolean = True);
        //! 繝輔ぃ繧､繝ｫ蜷阪°繧峨?繧ｹ繝ｬ繝?ラ菴懈?譌･縺ｮ蜿門ｾ?/span>
        function GetCreateDateFromName(FileName: String): TDateTime;
        function GetExtpreviewFileName: String;

        procedure ShowRefCount(msg: String; unk: IUnknown);
        //! 蜀帝匱縺ｮ譖ｸCookie蜿門ｾ?/span>
        function GetBoukenCookie(AURL: String): String;
        //! 蜀帝匱縺ｮ譖ｸCookie險ｭ螳?/span>
        procedure SetBoukenCookie(ACookieValue, ADomain: String);
        //! 蜀帝匱縺ｮ譖ｸCookie蜑企勁
        procedure DelBoukenCookie(ADomain: String);
        //! 蜀帝匱縺ｮ譖ｸDomain荳?隕ｧ蜿門ｾ?/span>
        procedure GetBoukenDomain(var ADomain: TStringList);
        //! 蜀帝匱縺ｮ譖ｸ繝峨Γ繧､繝ｳ蜷垢ookie蜿門ｾ?/span>
        function GetBouken(AURL: String; var Domain: String): String;
        end;

var
        GikoSys: TGikoSys;
const
        //LENGTH_RESTITLE                       = 40;
        ZERO_DATE: Integer      = 25569;
        BETA_VERSION_NAME_E = 'beta';
        BETA_VERSION_NAME_J = '?奇ｾ橸ｾ?';
        BETA_VERSION                            = 63;
        BETA_VERSION_BUILD      = '';                           //!< debug迚医↑縺ｩ
        APP_NAME                                                = 'gikoNavi';
        BE_PHP_URL = 'http://be.2ch.net/test/p.php?i=';


implementation

uses
        Giko, RoundData, Favorite, Registry, HTMLCreate, MojuUtils, Sort, YofUtils,
        IniFiles, DateUtils, SkinFiles;

const
        FOLDER_INDEX_VERSION                                    = '1.01';
        USER_AGENT                                                                              = 'Monazilla';
        DEFAULT_NGWORD_FILE_NAME : String = 'NGword.txt';
        NGWORDs_DIR_NAME : String               = 'NGwords';

        READ_PATH: string =                     '/test/read.cgi/';
    HTML_READ_PATH: string =        '/test/read.html/';
        OLD_READ_PATH: string =         '/test/read.cgi?';
        KAKO_PATH: string =                     '/kako/';

        KeyWordStr: array [TVerResourceKey] of String = (
                  'Comments',
                  'CompanyName',
                  'FileDescription',
                  'FileVersion',
                  'InternalName',
                  'LegalCopyright',
                  'LegalTrademarks',
                  'OriginalFilename',
                  'PrivateBuild',
                  'ProductName',
                  'ProductVersion',
                  'SpecialBuild');

// *************************************************************************
//! GikoSys繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
// *************************************************************************
constructor TGikoSys.Create;
begin
    Inherited;
        FSetting := TSetting.Create;
        FDolib := TDolib.Create;
    FBelib := TBelib.Create;
        FAWKStr := TAWKStr.Create(nil);
        if DirectoryExists(GetConfigDir) = false then begin
                CreateDir(GetConfigDir);
        end;
        FAbon := TAbon.Create;
    FAbon.IgnoreKana := FSetting.IgnoreKana;
        FAbon.Setroot(GetConfigDir+NGWORDs_DIR_NAME);
        FAbon.GoHome;
        FAbon.ReturnNGwordLineNum := FSetting.ShowNGLinesNum;
        FAbon.SetNGResAnchor := FSetting.AddResAnchor;
        FAbon.DeleteSyria := FSetting.DeleteSyria;
        FAbon.Deleterlo := FSetting.AbonDeleterlo;
        FAbon.Replaceul := FSetting.AbonReplaceul;
        FAbon.AbonPopupRes := FSetting.PopUpAbon;

        FSelectResFilter := TAbon.Create;
    FSelectResFilter.IgnoreKana := True;
        // 邨槭ｊ霎ｼ繧?縺ｨ縺阪?讌ｵ蜉帑ｸ?隕ｧ縺瑚ｦ九ｉ繧後ｋ縺ｻ縺?′縺?＞縺ｮ縺ｧ莉悶?螳悟?縺ｫ蜑企勁
        FSelectResFilter.AbonString := '';
    //
        ResRange := FSetting.ResRange;
        FVersion := Trim(GetVersionInfo(vrFileVersion));
        FBayesian := TGikoBayesian.Create;
        //FBoardURLList := TStringList.Create;
        //繝｡繝?そ繝ｼ繧ｸ縺ｮ菴懈?
        FGikoMessage := TGikoMessage.Create;
end;

// *************************************************************************
//! GikoSys繝?せ繝医Λ繧ｯ繧ｿ
// *************************************************************************
destructor TGikoSys.Destroy;
var
        i: Integer;
        FileList: TStringList;
begin
        //繝?Φ繝昴Λ繝ｪHTML繧貞炎髯､
        FileList := TStringList.Create;
        try
        FileList.BeginUpdate;
                GetFileList(GetTempFolder, '*.html', FileList, False, True);
        FileList.EndUpdate;
                for i := 0 to FileList.Count - 1 do begin
                        DeleteFile(FileList[i]);
                end;
        finally
                FileList.Free;
        end;
    FreeAndNil(FGikoMessage);
        FreeAndNil(FBayesian);
        FreeAndNil(FSelectResFilter);
        FreeAndNil(FAbon);
        FreeAndNil(FAWKStr);
    FreeAndNil(FBelib);
        FreeAndNil(FDolib);
        FreeAndNil(FSetting);
        inherited;
end;

{!
\brief 譁?ｭ怜?謨ｰ蟄励メ繧ｧ繝?け
\param s 繝√ぉ繝?け縺吶ｋ譁?ｭ怜?
\return s 縺檎ｬｦ蜿ｷ莉倥″謨ｴ謨ｰ縺ｨ縺励※隱崎ｭ伜庄閭ｽ縺ｪ繧 True
}
{$HINTS OFF}
function TGikoSys.IsNumeric(s: string): boolean;
var
        e: integer;
        v: integer;
begin
        Val(s, v, e);
        Result := e = 0;
end;
{$HINTS ON}

{!
\brief 譁?ｭ怜?豬ｮ蜍募ｰ乗焚轤ｹ謨ｰ蟄励メ繧ｧ繝?け
\param s 繝√ぉ繝?け縺吶ｋ譁?ｭ怜?
\return s 縺檎ｬｦ蜿ｷ莉倥″豬ｮ蜍募ｰ乗焚縺ｨ縺励※隱崎ｭ伜庄閭ｽ縺ｪ繧 True
}
function TGikoSys.IsFloat(s: string): boolean;
var
        v: Extended;
begin
        Result := TextToFloat(PChar(s), v, fvExtended);
end;

// *************************************************************************
//! 繝懊?繝峨ヵ繧｡繧､繝ｫ蜷榊叙蠕暦ｼ医ヱ繧ｹ?九ヵ繧｡繧､繝ｫ蜷搾ｼ?/span>
// *************************************************************************
function TGikoSys.GetBoardFileName: string;
begin
        Result := Setting.GetBoardFileName;
end;

// *************************************************************************
//! 繝懊?繝峨ヵ繧｡繧､繝ｫ蜷榊叙蠕暦ｼ医ヱ繧ｹ?九ヵ繧｡繧､繝ｫ蜷搾ｼ?/span>
// *************************************************************************
function TGikoSys.GetCustomBoardFileName: string;
begin
        Result := Setting.GetCustomBoardFileName;
end;

// *************************************************************************
//! 繝?Φ繝昴Λ繝ｪ繝輔か繝ｫ繝?繝ｼ蜷榊叙蠕?/span>
// *************************************************************************
function TGikoSys.GetHtmlTempFileName: string;
begin
        Result := Setting.GetHtmlTempFileName;
end;


// *************************************************************************
//! 螳溯｡後ヵ繧｡繧､繝ｫ繝輔か繝ｫ繝?蜿門ｾ?/span>
// *************************************************************************
function TGikoSys.GetAppDir: string;
begin
        Result := Setting.GetAppDir;
end;

// *************************************************************************
//! TempHtml繝輔ぃ繧､繝ｫ蜷榊叙蠕暦ｼ医ヱ繧ｹ?九ヵ繧｡繧､繝ｫ蜷搾ｼ?/span>
// *************************************************************************
function TGikoSys.GetTempFolder: string;
begin
        Result := Setting.GetTempFolder;
end;

// *************************************************************************
//! sent.ini繝輔ぃ繧､繝ｫ蜷榊叙蠕暦ｼ医ヱ繧ｹ?九ヵ繧｡繧､繝ｫ蜷搾ｼ?/span>
// *************************************************************************)
function TGikoSys.GetSentFileName: string;
begin
        Result := Setting.GetSentFileName;
end;

// *************************************************************************
//! outbox.ini繝輔ぃ繧､繝ｫ蜷榊叙蠕暦ｼ医ヱ繧ｹ?九ヵ繧｡繧､繝ｫ蜷搾ｼ?/span>
// *************************************************************************
function TGikoSys.GetOutBoxFileName: string;
begin
        Result := Setting.GetOutBoxFileName;
end;

// *************************************************************************
//! Config繝輔か繝ｫ繝?蜿門ｾ?/span>
// *************************************************************************
function TGikoSys.GetConfigDir: string;
begin
        Result := Setting.GetConfigDir;
end;

//! 繧ｹ繧ｿ繧､繝ｫ繧ｷ繝ｼ繝医ヵ繧ｩ繝ｫ繝?
function TGikoSys.GetStyleSheetDir: string;
begin
        Result := Setting.GetStyleSheetDir;
end;

//! 繧ｹ繧ｭ繝ｳ繝輔か繝ｫ繝?
function TGikoSys.GetSkinDir: string;
begin
        Result := Setting.GetSkinDir;
end;

//! Skin:繝倥ャ繝?縺ｮ繝輔ぃ繧､繝ｫ蜷?/span>
function TGikoSys.GetSkinHeaderFileName: string;
begin
        Result := Setting.SkinFiles.GetSkinHeaderFileName;
end;

//! Skin:繝輔ャ繧ｿ縺ｮ繝輔ぃ繧､繝ｫ蜷?/span>
function TGikoSys.GetSkinFooterFileName: string;
begin
        Result := Setting.SkinFiles.GetSkinFooterFileName;
end;

//! Skin:譁ｰ逹?繝ｬ繧ｹ縺ｮ繝輔ぃ繧､繝ｫ蜷?/span>
function TGikoSys.GetSkinNewResFileName: string;
begin
        Result := Setting.SkinFiles.GetSkinNewResFileName;
end;

//! Skin:髱樊眠逹?繝ｬ繧ｹ縺ｮ繝輔ぃ繧､繝ｫ蜷?/span>
function TGikoSys.GetSkinResFileName: string;
begin
        Result := Setting.SkinFiles.GetSkinResFileName;
end;

//! Skin:縺励♀繧?縺薙％縺ｾ縺ｧ隱ｭ繧薙□)縺ｮ繝輔ぃ繧､繝ｫ蜷?/span>
function TGikoSys.GetSkinBookmarkFileName: string;
begin
        Result := Setting.SkinFiles.GetSkinBookmarkFileName;
end;

//! Skin:縺励♀繧?譁ｰ逹?繝ｬ繧ｹ)縺ｮ繝輔ぃ繧､繝ｫ蜷?/span>
function TGikoSys.GetSkinNewmarkFileName: string;
begin
        Result := Setting.SkinFiles.GetSkinNewmarkFileName;
end;

//! UserAgent蜿門ｾ?/span>
function TGikoSys.GetUserAgent: string;
begin
        if Dolib.Connected then begin
                Result := Format('%s %s/%s%d/%s', [
                                                                Dolib.UserAgent,
                                                                APP_NAME,
                                                                BETA_VERSION_NAME_E,
                                                                BETA_VERSION,
                                                                Version]);
        end else begin
                Result := Format('%s/%s %s/%s%d/%s', [
                                                                USER_AGENT,
                                                                Dolib.Version,
                                                                APP_NAME,
                                                                BETA_VERSION_NAME_E,
                                                                BETA_VERSION,
                                                                Version]);
        end;
end;

{!
\brief 邨碁℃遘偵ｒ TDateTime 縺ｫ螟画鋤
\param val 1970/1/1/ 00:00:00 縺九ｉ縺ｮ邨碁℃遘?/span>
\return val 繧堤､ｺ縺 TDateTime
}
function TGikoSys.IntToDateTime(val: Int64): TDateTime;
begin
        Result := ZERO_DATE + val / 86400.0;
end;

{!
\brief TDateTime 繧堤ｵ碁℃遘偵↓螟画鋤
\param ADate 螟画鋤縺吶ｋ譎ょ綾
\return 1970/1/1/ 00:00:00 縺九ｉ縺ｮ邨碁℃遘?/span>
}
function TGikoSys.DateTimeToInt(ADate: TDateTime): Int64;
begin
        Result := Trunc((ADate - ZERO_DATE) * 86400);
end;


{!
\brief Subject繝輔ぃ繧､繝ｫRead
\param Board 繧ｹ繝ｬ荳?隕ｧ繧貞叙蠕励☆繧区攸
}
procedure TGikoSys.ReadSubjectFile(Board: TBoard);
var
        ThreadItem: TThreadItem;
        FileName: string;
        FileList: TStringList;
        Index: Integer;
        sl: TStringList;
        i: Integer;
        Rec: TIndexRec;
        UnRead: Integer;
        usePlugIn : Boolean;
        islog : Boolean;
    urlHead: String;
    datFileCheck: Boolean;
        {*
        FavoThreadItem : TFavoriteThreadItem;
        Node: TTreeNode;
        *}
{$IFDEF DEBUG}
    st, rt: Cardinal;
{$ENDIF}
begin
{$IFDEF DEBUG}
        st := GetTickCount;
{$ENDIF}
        if Board.IsThreadDatRead then
                Exit;
        Board.Clear;
        UnRead := 0;
        usePlugIn := Board.IsBoardPlugInAvailable;
        //server :=  UrlToServer( Board.URL );
    // 繧ｹ繝ｬ繝?ラ縺ｧ蜈ｱ騾壹?URL驛ｨ
    if Board.is2ch then begin
        urlHead := UrlToServer( Board.URL ) + 'test/read.cgi/' + Board.BBSID + '/';
    end else begin
        urlHead := UrlToServer( Board.URL ) + 'test/read.cgi?bbs=' + Board.BBSID + '&key=';
    end;

        FileName := Board.GetFolderIndexFileName;

    //
    datFileCheck := (Setting.CheckDatFile) or (not FileExists(FileName));
    if (datFileCheck) then begin
        FileList := TStringList.Create;
        FileList.Sorted := True;
        FileList.BeginUpdate;
        //IsLogFile逕ｨDAT繝輔ぃ繧､繝ｫ繝ｪ繧ｹ繝?/span>
        GetFileList(ExtractFileDir(Board.GetFolderIndexFileName), '*.dat', FileList, False);
        FileList.EndUpdate;
    end;

        // 驥崎､?ｒ髦ｲ縺?/span>
        Board.BeginUpdate;
        Board.Sorted := True;
        sl := TStringList.Create;
        try
                if FileExists(FileName) then begin
                        sl.LoadFromFile(FileName);
                        //?定｡檎岼縺九ｉ?茨ｼ題｡檎岼縺ｯ繝舌?繧ｸ繝ｧ繝ｳ??/span>
                        for i := sl.Count - 1 downto 1 do begin
                                Rec := ParseIndexLine(sl[i]);
                if (datFileCheck) then begin
                                islog := FileList.Find( Rec.FFileName, Index );
                end else begin
                    islog := (Rec.FSize <> 0) and (Rec.FCount <> 0);
                end;
                                if usePlugIn then
                                        ThreadItem := TThreadItem.Create(
                                                        Board.BoardPlugIn,
                                                        Board,
                                                        Board.BoardPlugIn.FileName2ThreadURL( DWORD( Board ), Rec.FFileName ) )
                                else begin
                                        if Board.is2ch then begin
                                                ThreadItem := TThreadItem.Create(
                                                        nil,
                                                        Board,
                                                        urlHead + ChangeFileExt( Rec.FFileName, '' ) + '/l50',
                                                        islog,
                                                        Rec.FFileName
                                                        );
                                        end else begin
                                                ThreadItem := TThreadItem.Create(
                                                        nil,
                                                        Board,
                                                        urlHead + ChangeFileExt( Rec.FFileName, '' ) + '&ls=50',
                                                        islog,
                                                        Rec.FFileName
                                                        );
                                        end;
                                end;

                                //ThreadItem.BeginUpdate;
                                if (datFileCheck) and (islog) then
                                        FileList.Delete( Index );

                                ThreadItem.No := Rec.FNo;
                                ThreadItem.FileName := Rec.FFileName;
                                ThreadItem.Title := MojuUtils.UnSanitize(Rec.FTitle);
                                ThreadItem.Count := Rec.FCount;
                                ThreadItem.Size := Rec.FSize;
                                ThreadItem.RoundDate := Rec.FRoundDate;
                                ThreadItem.LastModified := Rec.FLastModified;
                                ThreadItem.Kokomade := Rec.FKokomade;
                                ThreadItem.NewReceive := Rec.FNewReceive;
                                ThreadItem.UnRead := Rec.FUnRead;
                                ThreadItem.ScrollTop := Rec.FScrollTop;
                                ThreadItem.AllResCount := Rec.FAllResCount;
                                ThreadItem.NewResCount := Rec.FNewResCount;
                                ThreadItem.AgeSage := Rec.FAgeSage;
                                ThreadItem.ParentBoard := Board;
                                {* 縺頑ｰ励↓蜈･繧雁､ｧ驥冗函謌舌さ繝ｼ繝 *}
                                {*
                                FavoThreadItem := TFavoriteThreadItem.Create( ThreadItem.URL, ThreadItem.Title, ThreadItem );
                                Node := FavoriteDM.TreeView.Items.AddChildObject( FavoriteDM.TreeView.Items.Item[0], ThreadItem.Title, FavoThreadItem);
                                *}

                                //ThreadItem.EndUpdate;
                                Board.Add(ThreadItem);

                                if (ThreadItem.UnRead) and (ThreadItem.IsLogFile) then
                                        Inc(UnRead);
                        end;
                end;

                if UnRead <> Board.UnRead then
                        Board.UnRead := UnRead;

        if (datFileCheck) then begin
                    //繧､繝ｳ繝?ャ繧ｯ繧ｹ縺ｫ辟｡縺九▲縺溘Ο繧ｰ繧定ｿｽ蜉??郁?繧後う繝ｳ繝?ャ繧ｯ繧ｹ蟇ｾ蠢懶ｼ?/span>
            AddOutofIndexDat(Board, FileList);
        end;
                Board.EndUpdate;

        //蜑榊屓逡ｰ蟶ｸ邨ゆｺ?凾繝√ぉ繝?け
        RestoreThreadData( Board );
        finally
                sl.Free;
        if (datFileCheck) then begin
                FileList.Free;
        end;
                Board.Sorted := False;
        end;
        Board.IsThreadDatRead := True;
{$IFDEF DEBUG}
        rt := GetTickCount - st;
        Writeln('Read Done.' + Board.Title + ':' + IntToStr(rt) + ' ms');
{$ENDIF}
end;
{!
\brief 繧､繝ｳ繝?ャ繧ｯ繧ｹ縺ｫ縺ｪ縺?at?医?縺舌ｌdat?峨?霑ｽ蜉?
\param Board 霑ｽ蜉?縺吶ｋ譚ｿ
\param DatList  dat繝輔ぃ繧､繝ｫ蜷?/span>
}
procedure TGikoSys.AddOutofIndexDat(Board: TBoard; DatList: TStringList; AllCreate: Boolean = True);
var
    i : Integer;
    Boardpath,FileName : String;
    ResRec: TResRec;
    ThreadItem: TThreadItem;
    create: Boolean;
begin
    create := False;
    Boardpath := ExtractFilePath(Board.GetFolderIndexFileName);
    //繧､繝ｳ繝?ャ繧ｯ繧ｹ縺ｫ辟｡縺九▲縺溘Ο繧ｰ繧定ｿｽ蜉??郁?繧後う繝ｳ繝?ャ繧ｯ繧ｹ蟇ｾ蠢懶ｼ?/span>
    for i := 0 to DatList.Count - 1 do begin
        FileName := Boardpath + DatList[i];
        ThreadItem := nil;
        if (not AllCreate) then begin
            create := False;
            ThreadItem := Board.FindThreadFromFileName(DatList[i]);
            if (ThreadItem = nil) then begin
                create := True;
            end else begin
                if Board.IsBoardPlugInAvailable then begin
                    THTMLCreate.DivideStrLine(Board.BoardPlugIn.GetDat( DWORD( ThreadItem ), 1 ), @ResRec);
                end else begin
                    THTMLCreate.DivideStrLine(ReadThreadFile(FileName, 1), @ResRec);
                end;
            end;
        end;
        if (ThreadItem = nil) then begin
            if Board.IsBoardPlugInAvailable then begin
                ThreadItem := TThreadItem.Create(
                    Board.BoardPlugIn,
                    Board,
                    Board.BoardPlugIn.FileName2ThreadURL( DWORD( Board ), DatList[i] ) );
                THTMLCreate.DivideStrLine(Board.BoardPlugIn.GetDat( DWORD( ThreadItem ), 1 ), @ResRec);
            end else begin
                ThreadItem := TThreadItem.Create(
                    nil,
                    Board,
                    Get2chBoard2ThreadURL( Board, ChangeFileExt( DatList[i], '' ) ) );
                THTMLCreate.DivideStrLine(ReadThreadFile(FileName, 1), @ResRec);
            end;
        end;
        

        ThreadItem.BeginUpdate;
        ThreadItem.FileName := DatList[i];
        //ThreadItem.FilePath := FileName;
        ThreadItem.No := Board.Count + 1;
        ThreadItem.Title := ResRec.FTitle;
        ThreadItem.Count := GetFileLineCount(FileName);
        ThreadItem.AllResCount := ThreadItem.Count;
        ThreadItem.NewResCount := ThreadItem.Count;
        ThreadItem.Size := GetFileSize(FileName) - ThreadItem.Count;//1byte縺壹ｌ繧九→縺阪′縺ゅｋ縺代←縺昴ｌ縺ｯ縺ゅ″繧峨ａ繧?/span>
        ThreadItem.RoundDate := FileDateToDateTime( FileAge( FileName ) );
        ThreadItem.LastModified := ThreadItem.RoundDate;
        ThreadItem.Kokomade := -1;
        ThreadItem.NewReceive := 0;
        ThreadItem.ParentBoard := Board;
        ThreadItem.IsLogFile := True;
        ThreadItem.Round := False;
        ThreadItem.UnRead := False;
        ThreadItem.ScrollTop := 0;
        ThreadItem.AgeSage := gasNone;
        ThreadItem.EndUpdate;
        if (AllCreate) or (create) then begin
            Board.Add(ThreadItem);
        end;
    end;
end;
{!
\brief 繧ｹ繝ｬ繝?ラ繧､繝ｳ繝?ャ繧ｯ繧ｹ繝輔ぃ繧､繝ｫ(Folder.idx)菴懈?
\param Board Folder.idx 繧剃ｽ懈?縺吶ｋ譚ｿ
}
procedure TGikoSys.CreateThreadDat(Board: TBoard);
var
        i: integer;
        s: string;
        SubjectList: TStringList;
        sl: TStringList;
        Rec: TSubjectRec;
        FileName: string;
        cnt: Integer;
begin
        if not FileExists(Board.GetSubjectFileName) then Exit;
        FileName := Board.GetFolderIndexFileName;

        SubjectList := TStringList.Create;
        try
                SubjectList.LoadFromFile(Board.GetSubjectFileName);
                sl := TStringList.Create;
                try
                        cnt := 1;
                        sl.BeginUpdate;
                        sl.Add(FOLDER_INDEX_VERSION);
                        for i := 0 to SubjectList.Count - 1 do begin
                                Rec := DivideSubject(SubjectList[i]);

                                if (Trim(Rec.FFileName) = '') or (Trim(Rec.FTitle) = '') then
                                        Continue;

                                {s := Format('%x', [cnt]) + #1                                  //逡ｪ蜿ｷ
                                         + Rec.FFileName + #1                                                           //繝輔ぃ繧､繝ｫ蜷?/span>
                                         + Rec.FTitle + #1                                                                      //繧ｿ繧､繝医Ν
                                         + Format('%x', [Rec.FCount]) + #1      //繧ｫ繧ｦ繝ｳ繝?/span>
                                         + Format('%x', [0]) + #1                                               //size
                                         + Format('%x', [0]) + #1                                               //RoundDate
                                         + Format('%x', [0]) + #1                                               //LastModified
                                         + Format('%x', [0]) + #1                                               //Kokomade
                                         + Format('%x', [0]) + #1                                               //NewReceive
                                         + '0' + #1                                                                                             //譛ｪ菴ｿ逕ｨ
                                         + Format('%x', [0]) + #1                                               //UnRead
                                         + Format('%x', [0]) + #1                                               //ScrollTop
                                         + Format('%x', [Rec.FCount]) + #1      //AllResCount
                                         + Format('%x', [0]) + #1                                               //NewResCount
                                         + Format('%x', [0]);                                                           //AgeSage
                                }
                                s := Format('%x'#1'%s'#1'%s'#1'%x'#1'%x'#1'%x'#1'%x'#1'%x'#1'%x'#1 + 
                                                        '%s'#1'%x'#1'%x'#1'%x'#1'%x'#1'%x',
                                        [cnt,                   //逡ｪ蜿ｷ
                                         Rec.FFileName, //繝輔ぃ繧､繝ｫ蜷?/span>
                                         MojuUtils.Sanitize(Rec.FTitle),    //繧ｿ繧､繝医Ν
                                         Rec.FCount,     //繧ｫ繧ｦ繝ｳ繝?/span>
                                         0,             //size
                                         0,             //RoundDate
                                         0,                             //LastModified
                                         0,                             //Kokomade
                                         0,                             //NewReceive
                                         '0',                   //譛ｪ菴ｿ逕ｨ
                                         0,                             //UnRead
                                         0,                             //ScrollTop
                                         Rec.FCount,    //AllResCount
                                         0,                             //NewResCount
                                         0]             //AgeSage
                                        );

                                sl.Add(s);
                                inc(cnt);
                        end;
                        sl.EndUpdate;
                        sl.SaveToFile(FileName);
                finally
                        sl.Free;
                end;
        finally
                SubjectList.Free;
        end;
end;

{!
\brief 繧ｹ繝ｬ繝?ラ繧､繝ｳ繝?ャ繧ｯ繧ｹ(Thread.dat)譖ｸ縺崎ｾｼ縺ｿ
\param Thread.dat 繧剃ｽ懈?縺吶ｋ譚ｿ
}
procedure TGikoSys.WriteThreadDat(Board: TBoard);
//const
//      Values: array[Boolean] of string = ('0', '1');
var
        i: integer;
        FileName: string;
        sl: TStringList;
        s: string;
        TmpFileList: TStringList;
begin
        if not Board.IsThreadDatRead then
                Exit;
        FileName := Board.GetFolderIndexFileName;
        ForceDirectoriesEx( ExtractFilePath( FileName ) );

        sl := TStringList.Create;
        TmpFileList := TStringList.Create;
        TmpFileList.Sorted := true;
        try
        TmpFileList.BeginUpdate;
                GetFileList(ExtractFileDir(Board.GetFolderIndexFileName), '*.tmp', TmpFileList, false);
        TmpFileList.EndUpdate;
                sl.BeginUpdate;
                sl.Add(FOLDER_INDEX_VERSION);

                // 繧ｹ繝ｬ逡ｪ蜿ｷ菫晏ｭ倥?縺溘ａ繧ｽ繝ｼ繝?/span>
                Sort.SetSortNoFlag(true);
                Sort.SetSortOrder(true);
                Sort.SetSortIndex(0);
                //Sort.SortNonAcquiredCountFlag := GikoSys.Setting.NonAcquiredCount;
                Board.CustomSort(ThreadItemSortProc);

                for i := 0 to Board.Count - 1 do begin
                        Board.Items[i].No := i + 1;
                        s := Format('%x'#1'%s'#1'%s'#1'%x'#1'%x'#1'%x'#1'%x'#1'%x'#1'%x'#1 +
                                                        '%s'#1'%x'#1'%x'#1'%x'#1'%x'#1'%x',
                                        [Board.Items[i].No,                     //逡ｪ蜿ｷ
                                         Board.Items[i].FileName, //繝輔ぃ繧､繝ｫ蜷?/span>
                     MojuUtils.Sanitize(Board.Items[i].Title),    //繧ｿ繧､繝医Ν
                                         Board.Items[i].Count,     //繧ｫ繧ｦ繝ｳ繝?/span>
                                         Board.Items[i].Size,             //size
                                         DateTimeToInt(Board.Items[i].RoundDate),             //RoundDate
                                         DateTimeToInt(Board.Items[i].LastModified),                            //LastModified
                                         Board.Items[i].Kokomade,                               //Kokomade
                                         Board.Items[i].NewReceive,                             //NewReceive
                                         '0',                   //譛ｪ菴ｿ逕ｨ
                                         BoolToInt(Board.Items[i].UnRead),                              //UnRead
                                         Board.Items[i].ScrollTop,                              //ScrollTop
                                         Board.Items[i].AllResCount,    //AllResCount
                                         Board.Items[i].NewResCount,                            //NewResCount
                                         Ord(Board.Items[i].AgeSage)]             //AgeSage
                                        );

                        sl.Add(s);
                end;
                sl.EndUpdate;
                sl.SaveToFile(FileName);

                for i := 0 to TmpFileList.Count - 1 do begin
                        DeleteFile(ExtractFilePath(Board.GetFolderIndexFileName) + TmpFileList[i]);
                end;

        finally
                TmpFileList.Free;
                sl.Free;
        end;
end;

{!
\brief Folder.idx 繧 1 陦瑚ｧ｣驥?/span>
\param Line Folder.idx 繧呈ｧ区?縺吶ｋ 1 陦?/span>
\return 繧ｹ繝ｬ繝?ラ諠??ｱ
}
function TGikoSys.ParseIndexLine(Line: string): TIndexRec;
begin
        Result.FNo := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0);
        Result.FFileName := MojuUtils.RemoveToken(Line, #1);
        Result.FTitle := MojuUtils.UnSanitize(MojuUtils.RemoveToken(Line, #1));
        Result.FCount := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0);
        Result.FSize := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0);
        Result.FRoundDate := IntToDateTime(StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), ZERO_DATE));
        Result.FLastModified := IntToDateTime(StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), ZERO_DATE));
        Result.FKokomade := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), -1);
        Result.FNewReceive := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0);
        MojuUtils.RemoveToken(Line, #1);//9: ;  //譛ｪ菴ｿ逕ｨ
        Result.FUnRead := IntToBool(StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0));
        Result.FScrollTop := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0);
        Result.FAllResCount := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0);
        Result.FNewResCount := StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0);
        Result.FAgeSage := TGikoAgeSage(StrToIntDef('$' + MojuUtils.RemoveToken(Line, #1), 0));

end;

{!
\brief 謖?ｮ壹ヵ繧ｩ繝ｫ繝?蜀??謖?ｮ壹ヵ繧｡繧､繝ｫ荳?隕ｧ繧貞叙蠕励☆繧?/span>
\param Path      襍ｷ轤ｹ縺ｨ縺ｪ繧九ヵ繧ｩ繝ｫ繝?繝代せ
\param Mask      繝輔ぃ繧､繝ｫ蜷阪?繝槭せ繧ｯ
\param List      OUT:蜿門ｾ励＆繧後◆繝輔ぃ繧､繝ｫ蜷堺ｸ?隕ｧ縺瑚ｿ斐ｋ
\param SubDir    荳ｭ縺ｮ繝輔か繝ｫ繝?縺ｾ縺ｧ蜀榊ｸｰ逧?↓繝ｪ繧ｹ繝医☆繧句?ｴ蜷医? True
\param IsPathAdd 繝代せ莉倥″縺ｧ繝ｪ繧ｹ繝医い繝??縺吶ｋ蝣ｴ蜷医? True

Mask 繧 '*.txt' 縺ｮ繧医≧縺ｫ謖?ｮ壹☆繧九％縺ｨ縺ｧ縲?/span>
迚ｹ螳壹?繝輔ぃ繧､繝ｫ蜷阪ｄ迚ｹ螳壹?諡｡蠑ｵ蟄舌↓邨槭▲縺溘Μ繧ｹ繝医い繝??縺悟庄閭ｽ縺ｧ縺吶??/span>

\par 萓?
\code
GetFileList('c:\', '*.txt', list, True, True);
\endcode
}
procedure TGikoSys.GetFileList(Path: string; Mask: string; var List: TStringList; SubDir: Boolean; IsPathAdd: Boolean);
var
        rc: Integer;
        SearchRec : TSearchRec;
        s: string;
begin
        Path := IncludeTrailingPathDelimiter(Path);
        rc := FindFirst(Path + '*.*', faAnyfile, SearchRec);
        try
                while rc = 0 do begin
                        if (SearchRec.Name <> '..') and (SearchRec.Name <> '.') then begin
                                s := Path + SearchRec.Name;

                                if (SearchRec.Attr and faDirectory = 0) and (MatchesMask(s, Mask)) then
                                                if IsPathAdd then
                                                        List.Add(s)
                                                else
                                                        List.Add(SearchRec.Name);
                                if SubDir and (SearchRec.Attr and faDirectory > 0) then
                                        GetFileList(s, Mask, List, True, IsPathAdd);
                        end;
                        rc := FindNext(SearchRec);
                end;
        finally
                SysUtils.FindClose(SearchRec);
        end;
        List.Sort;
end;

{!
\breif 謖?ｮ壹ヵ繧ｩ繝ｫ繝?蜀??謖?ｮ壹ヵ繧｡繧､繝ｫ荳?隕ｧ繧貞叙蠕励☆繧九??/span>
                         繧ｵ繝悶ヵ繧ｩ繝ｫ繝?縺ｯ讀懃ｴ｢縺励↑縺?/span>
\param Path      襍ｷ轤ｹ縺ｨ縺ｪ繧九ヵ繧ｩ繝ｫ繝?繝代せ
\param Mask      繝輔ぃ繧､繝ｫ蜷阪?繝槭せ繧ｯ
\param List      OUT:蜿門ｾ励＆繧後◆繝輔ぃ繧､繝ｫ蜷堺ｸ?隕ｧ縺瑚ｿ斐ｋ
\param IsPathAdd 繝代せ莉倥″縺ｧ繝ｪ繧ｹ繝医い繝??縺吶ｋ蝣ｴ蜷医? True
\note 蜀崎ｵｷ謖?ｮ壼庄閭ｽ縺ｪ GetFileList() 縺後≠繧九?縺ｧ縺薙?髢｢謨ｰ縺ｯ荳崎ｦ?
\par 萓?/span>
\code
GetFileList('c:\', '*.txt', list, True);
\endcode
}
procedure TGikoSys.GetFileList(Path: string; Mask: string; var List: TStringList; IsPathAdd: Boolean);
var
        rc: Integer;
        SearchRec : TSearchRec;
begin
        Path := IncludeTrailingPathDelimiter(Path);
        rc := FindFirst(Path + Mask, faAnyfile, SearchRec);
        try
                while rc = 0 do begin
                        if (SearchRec.Name <> '..') and (SearchRec.Name <> '.') then begin
                                if (SearchRec.Attr and faDirectory = 0) then begin
                    if IsPathAdd then begin
                        List.Add(Path + SearchRec.Name)
                    end else begin
                        List.Add(SearchRec.Name);
                    end;
                end;
                        end;
                        rc := FindNext(SearchRec);
                end;
        finally
                SysUtils.FindClose(SearchRec);
        end;
        List.Sort;
end;

{!
\brief 謖?ｮ壹ヵ繧ｩ繝ｫ繝?蜀??繝?ぅ繝ｬ繧ｯ繝医Μ荳?隕ｧ繧貞叙蠕励☆繧?/span>
\param Path      襍ｷ轤ｹ縺ｨ縺ｪ繧九ヵ繧ｩ繝ｫ繝?繝代せ
\param Mask      繝輔か繝ｫ繝?蜷阪?繝槭せ繧ｯ
\param List      OUT:蜿門ｾ励＆繧後◆繝輔か繝ｫ繝?蜷堺ｸ?隕ｧ縺瑚ｿ斐ｋ
\param SubDir    荳ｭ縺ｮ繝輔か繝ｫ繝?縺ｾ縺ｧ蜀榊ｸｰ逧?↓繝ｪ繧ｹ繝医☆繧句?ｴ蜷医? True

Mask 繧 '*.txt' 縺ｮ繧医≧縺ｫ謖?ｮ壹☆繧九％縺ｨ縺ｧ縲?/span>
迚ｹ螳壹?繝輔ぃ繧､繝ｫ蜷阪ｄ迚ｹ螳壹?諡｡蠑ｵ蟄舌↓邨槭▲縺溘Μ繧ｹ繝医い繝??縺悟庄閭ｽ縺ｧ縺吶??/span>

\par 萓?
\code
GetDirectoryList('c:\', '*.txt', list, True);
\endcode
}
procedure TGikoSys.GetDirectoryList(Path: string; Mask: string; List: TStringList; SubDir: Boolean);
var
        rc: Integer;
        SearchRec : TSearchRec;
        s: string;
begin
        Path := IncludeTrailingPathDelimiter(Path);
        rc := FindFirst(Path + '*.*', faDirectory, SearchRec);
        try
                while rc = 0 do begin
                        if (SearchRec.Name <> '..') and (SearchRec.Name <> '.') then begin
                                s := Path + SearchRec.Name;
                                //if (SearchRec.Attr and faDirectory > 0) then
                                //      s := IncludeTrailingPathDelimiter(s)

                                if (SearchRec.Attr and faDirectory > 0) and (MatchesMask(s, Mask)) then
                                        List.Add( IncludeTrailingPathDelimiter( s ) );
                                if SubDir and (SearchRec.Attr and faDirectory > 0) then
                                        GetDirectoryList(s, Mask, List, True);
                        end;
                        rc := FindNext(SearchRec);
                end;
        finally
                SysUtils.FindClose(SearchRec);
        end;
end;


{!
\brief Subject.txt 荳?陦後ｒ隗｣驥?/span>
\param Line Subject.txt 繧呈ｧ区?縺吶ｋ 1 陦?/span>
\return     繧ｹ繝ｬ繝?ラ諠??ｱ
}
function TGikoSys.DivideSubject(Line: string): TSubjectRec;
var
        i: integer;
        ws: WideString;
        Delim: string;
        LeftK: string;
        RightK: string;
begin
        Result.FCount := 0;

        if AnsiPos('<>', Line) = 0 then
                Delim := ','
        else
                Delim := '<>';
        Result.FFileName := MojuUtils.RemoveToken(Line, Delim);
        Result.FTitle := Trim(MojuUtils.RemoveToken(Line, Delim));

        ws := Result.FTitle;
        if Copy(ws, Length(ws), 1) = ')' then begin
                LeftK := '(';
                RightK := ')';
        end else if Copy(ws, Length(ws)-1, 2) = '??#39; then begin
                LeftK := '??#39;;
                RightK := '??#39;;
        end else if Copy(ws, Length(ws), 1) = '>' then begin
                LeftK := '<';
                RightK := '>';
        end;
        for i := Length(ws) - 1 downto 1 do begin
                if Copy(ws, i, Length(LeftK)) = LeftK then begin
                        Result.FTitle := TrimRight(Copy(ws, 1, i - 1));
                        ws := Copy(ws, i + Length(LeftK), Length(ws) - i - Length(RightK));
                        if IsNumeric(ws) then
                                Result.FCount := StrToInt(ws);
                        //Delete(Result.FTitle, i, Length(LeftK) + Length(ws) + Length(RightK));
                        break;
                end;
        end;
end;

{!
\brief URL縺九ｉBBSID繧貞叙蠕?/span>
\param url BBSID 繧貞叙蠕励☆繧 URL
\return    BBSID
}
function TGikoSys.UrlToID(url: string): string;
var
        i: integer;
begin
        Result := '';
        url := Trim(url);

        if url = '' then Exit;
        try
                url := Copy(url, 0, Length(url) - 1);
                for i := Length(url) downto 0 do begin
                        if url[i] = '/' then begin
                                Result := Copy(url, i + 1, Length(url));
                                Break;
                        end;
                end;
        except
                Result := '';
        end;
end;

{!
\brief URL縺九ｉ譛?蠕後?隕∫ｴ?繧貞炎髯､
\param url 隗｣驥医☆繧 URL
\return    蛻?ｊ蜿悶ｉ繧後◆蠕後? URL

URL 縺九ｉ BBSID莉･螟悶?驛ｨ蛻?ｒ蜿門ｾ励☆繧九?縺ｫ菴ｿ逕ｨ縺励∪縺吶??/span>
}
function TGikoSys.UrlToServer(url: string): string;
var
        i: integer;
        wsURL: WideString;
begin
        Result := '';
        wsURL := url;
        wsURL := Trim(wsURL);

        if wsURL = '' then exit;

        if Copy(wsURL, Length(wsURL), 1) = '/' then
                wsURL := Copy(wsURL, 0, Length(wsURL) - 1);

        for i := Length(wsURL) downto 0 do begin
                if wsURL[i] = '/' then begin
                        Result := Copy(wsURL, 0, i);
                        break;
                end;
        end;
end;

{!
\brief 繝?ぅ繝ｬ繧ｯ繝医Μ縺悟ｭ伜惠縺吶ｋ縺九メ繧ｧ繝?け
\param Name 蟄伜惠繧堤｢ｺ隱阪☆繧九ヵ繧ｩ繝ｫ繝?繝代せ
\return     繝輔か繝ｫ繝?縺悟ｭ伜惠縺吶ｋ縺ｪ繧 True
}
function TGikoSys.DirectoryExistsEx(const Name: string): Boolean;
var
        Code: Cardinal;
begin
        Code := GetFileAttributes(PChar(Name));
        Result := (Code <> Cardinal(-1)) and (FILE_ATTRIBUTE_DIRECTORY and Code <> 0);
end;

{!
\brief 繝?ぅ繝ｬ繧ｯ繝医Μ菴懈??郁､?焚髫主ｱ､蟇ｾ蠢懶ｼ?/span>
\param Dir 菴懈?縺吶ｋ繝代せ
\return    菴懈?縺ｫ謌仙粥縺励◆蝣ｴ蜷医? True
}
function TGikoSys.ForceDirectoriesEx(Dir: string): Boolean;
begin
        Result := True;
        if Length(Dir) = 0 then
                raise Exception.Create('繝輔か繝ｫ繝?縺御ｽ懈?蜃ｺ譚･縺ｾ縺帙ｓ');
        Dir := ExcludeTrailingPathDelimiter(Dir);
        if (Length(Dir) < 3) or DirectoryExistsEx(Dir)
                or (ExtractFilePath(Dir) = Dir) then Exit; // avoid 'xyz:\' problem.
        Result := ForceDirectoriesEx(ExtractFilePath(Dir)) and CreateDir(Dir);
end;

{!
\brief 譁?ｭ怜?縺九ｉ繝医?繧ｯ繝ｳ縺ｮ蛻?ｊ蜃ｺ縺暦ｼ亥?譛溷?逅?ｼ?/span>
                         FDelphi縺九ｉ縺ｮ繝代け繝ｪ
\param s   蜈?↓縺ｪ繧九く繝｣繝ｩ繧ｯ繧ｿ
\param sep 蛹ｺ蛻?ｊ縺ｫ縺ｪ繧区枚蟄怜?
\param Rec OUT:譁?ｭ怜?襍ｰ譟ｻ諠??ｱ縺瑚ｿ斐ｋ
\return    蛻?ｊ蜃ｺ縺励◆繝医?繧ｯ繝ｳ
\todo Split, RemoveToken, GetTokenIndex, NthField 陦後″
}
function TGikoSys.StrTokFirst(const s:string; const sep: TStrTokSeparator; var Rec: TStrTokRec): string;
begin
        Rec.Str := s;
        Rec.Pos := 1;
        Result := StrTokNext(sep, Rec);
end;

{!
\brief 譁?ｭ怜?縺九ｉ繝医?繧ｯ繝ｳ縺ｮ蛻?ｊ蜃ｺ縺?/span>
                         FDelphi縺九ｉ縺ｮ繝代け繝ｪ
\param sep 蛹ｺ蛻?ｊ縺ｫ縺ｪ繧九く繝｣繝ｩ繧ｯ繧ｿ
\param Rec IN/OUT:StrTokFirst縺ｧ菴懈?縺輔ｌ縺滓枚蟄怜?襍ｰ譟ｻ諠??ｱ
\return    蛻?ｊ蜃ｺ縺励◆繝医?繧ｯ繝ｳ
\todo Split, RemoveToken, GetTokenIndex, NthField 陦後″
}
function TGikoSys.StrTokNext(const sep: TStrTokSeparator; var Rec: TStrTokRec): string;
var
        Len, I: Integer;
begin
        with Rec do     begin
                Len := Length(Str);
                Result := '';
                if Len >= Pos then begin
                        while (Pos <= Len) and (Str[Pos] in sep) do begin
                         Inc(Pos);
                        end;
                        I := Pos;
                        while (Pos<= Len) and not (Str[Pos] in sep) do begin
                                if IsDBCSLeadByte(Byte(Str[Pos])) then begin
                                        Inc(Pos);
                                end;
                                Inc(Pos);
                        end;
                        Result := Copy(Str, I, Pos - I);
                        while (Pos <= Len) and (Str[Pos] in sep) do begin// 縺薙ｌ縺ｯ縺雁･ｽ縺ｿ
                                Inc(Pos);
                        end;
                end;
        end;
end;

{!
\brief 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ蜿門ｾ?/span>
\param FileName 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ繧貞叙蠕励☆繧九ヵ繧｡繧､繝ｫ繝代せ
\return         繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ(bytes)
}
function TGikoSys.GetFileSize(FileName : string): longint;
var
        F : File;
begin
        try
                if not FileExists(FileName) then begin
                        Result := 0;
                        Exit;
                end;
                Assign(F, FileName);
                Reset(F, 1);
                Result := FileSize(F);
                CloseFile(F);
        except
                Result := 0;
        end;
end;

{!
\brief 繝?く繧ｹ繝医ヵ繧｡繧､繝ｫ縺ｮ陦梧焚繧貞叙蠕?/span>
\param FileName 陦梧焚繧貞叙蠕励☆繧九ヵ繧｡繧､繝ｫ繝代せ
\return         陦梧焚
\todo 繝｡繝｢繝ｪ繝槭ャ繝励ラ繝輔ぃ繧､繝ｫ陦後″
}
function TGikoSys.GetFileLineCount(FileName : string): longint;
var
        sl: TStringList;
begin
        sl := TStringList.Create;
        try
                try
                        sl.LoadFromFile(FileName);
                        Result := sl.Count;
                except
                        Result := 0;
                end;
        finally
                sl.Free;
        end;

end;

{!
\brief 繝輔ぃ繧､繝ｫ縺九ｉ謖?ｮ夊｡後ｒ蜿門ｾ?/span>
\param FileName 繝輔ぃ繧､繝ｫ縺ｮ繝代せ
\param Line     謖?ｮ夊｡?/span>
\return         謖?ｮ壹＆繧後◆ 1 陦?/span>
\todo 繝｡繝｢繝ｪ繝槭ャ繝励ラ繝輔ぃ繧､繝ｫ陦後″
}
function TGikoSys.ReadThreadFile(FileName: string; Line: Integer): string;
var
        fileTmp : TStringList;
begin
        Result := '';
        if FileExists(FileName) then begin
                fileTmp := TStringList.Create;
                try
                        try
                                fileTmp.LoadFromFile( FileName );
                                if ( Line       >= 1 ) and ( Line       < fileTmp.Count + 1 ) then begin
                                        Result := fileTmp.Strings[ Line-1 ];
                                end;
                        except
                                //on EFOpenError do Result := '';
                        end;
                finally
                        fileTmp.Free;
                end;
        end;
end;

{!
\brief 繧ｷ繧ｹ繝?Β繝｡繝九Η繝ｼ繝輔か繝ｳ繝医?螻樊?ｧ繧貞叙蠕?/span>
\param Font OUT:蜿門ｾ励＠縺溘ヵ繧ｩ繝ｳ繝亥ｱ樊?ｧ縺瑚ｿ斐ｋ
}
procedure TGikoSys.MenuFont(Font: TFont);
var
        lf: LOGFONT;
        nm: NONCLIENTMETRICS;
begin
        nm.cbSize := sizeof(NONCLIENTMETRICS);
    SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, @nm, 0);
    lf := nm.lfMenuFont;
    Font.Name := lf.lfFaceName;
    Font.Height := lf.lfHeight;
    Font.Style := [];
    if lf.lfWeight >= 700 then
        Font.Style := Font.Style + [fsBold];
    if lf.lfItalic = 1 then
        Font.Style := Font.Style + [fsItalic];
end;

{!
\brief 蜈磯?ｭ縺ｮ繝医?繧ｯ繝ｳ繧貞?繧雁?縺?/span>
\param s         IN/OUT:蜈?↓縺ｪ繧区枚蟄怜?縲∝?繧雁?縺励◆蠕後?谿九ｊ縺ｮ譁?ｭ怜?
\param delimiter 蛹ｺ蛻?ｊ縺ｫ縺ｪ繧区枚蟄怜?
\return          蛻?ｊ蜃ｺ縺励◆譁?ｭ怜?

縺ｩ縺薙°縺ｮ繧ｵ繧､繝医°繧峨?繝代け繝ｪ
}
{function TGikoSys.RemoveToken(var s: string;const delimiter: string): string;
var
        p: Integer;
begin
        p := AnsiPos(delimiter, s);
        if p = 0 then
                Result := s
        else
                Result := Copy(s, 1, p - 1);
        Delete(s, 1, Length(Result) + Length(delimiter));
end;
}

{!
\brief n 蛟狗岼縺ｮ繝医?繧ｯ繝ｳ繧貞?繧雁?縺?/span>
\param s     蜈?↓縺ｪ繧区枚蟄怜?
\param index 0 縺九ｉ蟋九∪繧九う繝ｳ繝?ャ繧ｯ繧ｹ(n 蛟狗岼縺ｮ n)
\return 蛻?ｊ蜃ｺ縺励◆繝医?繧ｯ繝ｳ

縺ｩ縺薙°縺ｮ繧ｵ繧､繝医°繧峨?繝代け繝ｪ
}
function TGikoSys.GetTokenIndex(s: string; delimiter: string; index: Integer): string;
var
        i: Integer;
begin
        Result := '';
        for i := 0 to index do
                Result := MojuUtils.RemoveToken(s, delimiter);
end;


//繧､繝ｳ繝?ャ繧ｯ繧ｹ譛ｪ譖ｴ譁ｰ繝舌ャ繝輔ぃ繧偵ヵ繝ｩ繝?す繝･??/span>
{procedure TGikoSys.FlashExitWrite;
var
        i: Integer;
begin
        //繧ｹ繝ｬ繝?ラ繝??繧ｿ繝輔ぃ繧､繝ｫ繧呈峩譁ｰ
        for i := 0 to FExitWrite.Count - 1 do
                WriteThreadDat(FExitWrite[i]);
        FExitWrite.Clear;
end;}

{!
\brief 繧ｹ繝ｬ蜷阪↑縺ｩ繧堤洒縺?錐蜑阪↓螟画鋤縺吶ｋ
\param LongName 蜈?↓縺ｪ繧区枚蟄怜?
\param ALength  蜿弱ａ繧区枚蟄怜?髟ｷ(bytes)
\return         螟画鋤縺輔ｌ縺滓枚蟄怜?

from HotZonu
}
function TGikoSys.GetShortName(const LongName: string; ALength: integer): string;
const
        ERASECHAR : array [1..39] of string =
                ('笘?#39;,'笘?#39;,'笆?','笆｡','笳?#39;,'笳?#39;,'?ｿ','??#39;,'笆ｲ','笆ｼ',
                 '笆ｳ','笆ｽ','笳?#39;,'笳?#39;,'笳?#39;,'縲?#39;,'縲?#39;,'笙ｪ','縲?#39;,'縲?#39;,
                 '窶?#39;,'窶?#39;,'縲?#39;,'縲?#39;,'窶?#39;,'窶?#39;,'??#39;,'??#39;,'竕ｪ','竕ｫ',
                 '??#39;,'??#39;,'縲?#39;,'縲?#39;,'縲?#39;,'縲?#39;,'縲?#39;,'窶ｦ', '縲?');
var
        Chr : array [0..255]    of      char;
        S : string;
        i : integer;
begin
        s := Trim(LongName);
        if (Length(s) <= ALength) then begin
                Result := s;
        end else begin
                S := s;
                for i := Low(ERASECHAR) to      High(ERASECHAR) do      begin
                        S := CustomStringReplace(S, ERASECHAR[i], '');
                end;
                if (Length(S) <= ALength) then begin
                        Result := S;
                end else begin
                        Windows.LCMapString(
                                        GetUserDefaultLCID(),
                                        LCMAP_HALFWIDTH,
                                        PChar(S),
                                        Length(S) + 1,
                                        chr,
                                        Sizeof(chr)
                                        );
                        S := Chr;
                        S := Copy(S,1,ALength);
                        while true do begin
                                if (ByteType(S, Length(S)) = mbLeadByte ) then begin
                                        S := Copy(S, 1, Length(S) - 1);
                                end else begin
                                        Break;
                                end;
                        end;
                        Result := S;
                end;
        end;
end;

{!
\brief Boolean 繧 Integer 縺ｫ螟画鋤
\return False..0, True..1
}
function TGikoSys.BoolToInt(b: Boolean): Integer;
begin
        Result := IfThen(b, 1, 0);
end;

{!
\brief Integer 繧 Boolean 縺ｫ螟画鋤
\return 1..True, other..False
\todo 0..False, other..True 縺ｮ譁ｹ縺後＞縺??縺ｧ縺ｯ?
                        (縺薙?莉墓ｧ倥↓萓晏ｭ倥＠縺ｦ縺?ｋ縺九ｂ縺励ｌ縺ｪ縺??縺ｧ譛ｪ菫ｮ豁｣)
}
function TGikoSys.IntToBool(i: Integer): Boolean;
begin
        Result := i = 1;
end;

{!
\brief gzip縺ｧ蝨ｧ邵ｮ縺輔ｌ縺溘?繧呈綾縺?/span>
\param ResStream       隱ｭ縺ｿ霎ｼ繧?繧ｹ繝医Μ繝ｼ繝?
\param ContentEncoding 繧ｨ繝ｳ繧ｳ繝ｼ繝?ぅ繝ｳ繧ｰ
\return                螻暮幕縺輔ｌ縺滓枚蟄怜?
}
function TGikoSys.GzipDecompress(ResStream: TStream; ContentEncoding: string): string;
const
        BUF_SIZE = 4096;
var
        GZipStream: TGzipDecompressStream;
        TextStream: TStringStream;
        buf: array[0..BUF_SIZE - 1] of Byte;
        cnt: Integer;
        s: string;
        i, ln: Integer;
begin
        Result := '';
        TextStream := TStringStream.Create('');
        try
//繝弱?繝医Φ繧ｦ繝ｳ繝√え繧｣繝ｫ繧ｹ2003蟇ｾ遲?x-gzip縺ｨ縺九↓縺ｪ繧九∩縺溘＞)
//              if LowerCase(Trim(ContentEncoding)) = 'gzip' then begin
                if AnsiPos('gzip', LowerCase(Trim(ContentEncoding))) > 0 then begin
                        ResStream.Position := 0;
                        GZipStream := TGzipDecompressStream.Create(TextStream);
                        try
                                repeat
                                        FillChar(buf, BUF_SIZE, 0);
                                        cnt := ResStream.Read(buf, BUF_SIZE);
                                        if cnt > 0 then
                                                GZipStream.Write(buf, BUF_SIZE);
                                until cnt = 0;
                        finally
                                GZipStream.Free;
                        end;
                end else begin
                        ResStream.Position := 0;
                        repeat
                                FillChar(buf, BUF_SIZE, 0);
                                cnt := ResStream.Read(buf, BUF_SIZE);
                                if cnt > 0 then
                                        TextStream.Write(buf, BUF_SIZE);
                        until cnt = 0;
                end;

                //NULL譁?ｭ励ｒ"*"縺ｫ縺吶ｋ
                s := TextStream.DataString;
                i := Length(s);
                ln := i;
                while (i > 0) and (s[i] = #0) do
                        Dec(i);
                Delete(s, i + 1, ln - i);

                i := Pos(#0, s);
                while i <> 0 do begin
                        s[i] := '*';
                        i := Pos(#0, s);
                end;

                Result := s;
        finally
                TextStream.Free;
        end;
end;

{!
\brief 繧｢繧ｯ繧ｷ繝ｧ繝ｳ縺ｫ繧ｷ繝ｧ繝ｼ繝医き繝?ヨ繧ｭ繝ｼ繧定ｨｭ螳?/span>
\param ActionList 險ｭ螳壹☆繧九い繧ｯ繧ｷ繝ｧ繝ｳ荳?隕ｧ
\param FileName Ini繝輔ぃ繧､繝ｫ縺ｮ蜷榊燕
}
procedure TGikoSys.LoadKeySetting(ActionList: TActionList; FileName: String);
const
        STD_SEC = 'KeySetting';
var
        i: Integer;
        ini: TMemIniFile;
        ActionName: string;
        ActionKey: Integer;
        SecList: TStringList;
        Component: TComponent;
begin
        if not FileExists(fileName) then
                Exit;
        SecList := TStringList.Create;
        ini := TMemIniFile.Create(fileName);
        try
                ini.ReadSection(STD_SEC, SecList);
                for i := 0 to SecList.Count - 1 do begin
                        ActionName := SecList[i];
                        ActionKey := ini.ReadInteger(STD_SEC, ActionName, -1);
                        if ActionKey <> -1 then begin
                                Component := ActionList.Owner.FindComponent(ActionName);
                                if TObject(Component) is TAction then begin
                                        TAction(Component).ShortCut := ActionKey;
                                end;
                        end;
                end;
        finally
                ini.Free;
                SecList.Free;
        end;
end;

{!
\brief 繧｢繧ｯ繧ｷ繝ｧ繝ｳ縺ｫ險ｭ螳壹＆繧後※縺?ｋ繧ｷ繝ｧ繝ｼ繝医き繝?ヨ繧ｭ繝ｼ繧偵ヵ繧｡繧､繝ｫ縺ｫ菫晏ｭ?/span>
\param ActionList 菫晏ｭ倥☆繧九い繧ｯ繧ｷ繝ｧ繝ｳ荳?隕ｧ
\param FileName Ini繝輔ぃ繧､繝ｫ蜷?/span>

ActionList 縺ｫ險ｭ螳壹＆繧後※縺?ｋ繧ｷ繝ｧ繝ｼ繝医き繝?ヨ繧ｭ繝ｼ繧 FileName 縺ｫ菫晏ｭ倥＠縺ｾ縺吶??/span>
}
procedure TGikoSys.SaveKeySetting(ActionList: TActionList; FileName: String);
const
        STD_SEC = 'KeySetting';
var
        i: Integer;
        ini: TMemIniFile;
begin
        ini := TMemIniFile.Create(GetConfigDir + FileName);
        try
                for i := 0 to ActionList.ActionCount - 1 do begin
                        if ActionList.Actions[i].Tag = -1 then
                                Continue;
                        ini.WriteInteger(STD_SEC, ActionList.Actions[i].Name, TAction(ActionList.Actions[i]).ShortCut);
                end;
                ini.UpdateFile;
        finally
                ini.Free;
        end;
end;


{!
\brief 繝励Ο繧ｻ繧ｹ縺ｮ逕滓?
\param AppPath 襍ｷ蜍輔☆繧九?繝ｭ繧ｻ繧ｹ縺ｮ繝輔ぃ繧､繝ｫ繝代せ
\param Param   AppPath 縺ｫ貂｡縺吝ｼ墓焚
}
procedure TGikoSys.CreateProcess(const AppPath: string; const Param: string);
var
        PI: TProcessInformation;
        SI: TStartupInfo;
        Path: string;
begin
        Path := '"' + AppPath + '"';
        if Param <> '' then
                Path := Path + ' ' + Param;

        SI.Cb := SizeOf(Si);
        SI.lpReserved   := nil;
        SI.lpDesktop     := nil;
        SI.lpTitle               := nil;
        SI.dwFlags               := 0;
        SI.cbReserved2 := 0;
        SI.lpReserved2 := nil;
        SI.dwysize               := 0;
    if Windows.CreateProcess(nil,
                                                                PChar(Path),
                                                                nil,
                                                                nil,
                                                                False,
                                                                0,
                                                                nil,
                                                                nil,
                                                                SI,
                                                                PI) then
    begin
        CloseHandle(PI.hProcess);
    end;

end;

{!
\brief Web 繝悶Λ繧ｦ繧ｶ繧定ｵｷ蜍?/span>
\param URL         Web 繝悶Λ繧ｦ繧ｶ縺ｧ陦ｨ遉ｺ縺吶ｋ URL
\param BrowserType 繝悶Λ繧ｦ繧ｶ縺ｮ繧ｿ繧､繝?IE 縺九←縺?°)
}
procedure TGikoSys.OpenBrowser(URL: string; BrowserType: TGikoBrowserType);
var
    i, j : Integer;
    path, arg : String;
    params : TStringList;
begin
        case BrowserType of
                gbtIE:
                        HlinkNavigateString(nil, PWideChar(WideString(URL)));
                gbtUserApp, gbtAuto:
                        if (Setting.URLApp) then begin
                if (FileExists(Setting.URLAppFile)) then begin
                                GikoSys.CreateProcess(Setting.URLAppFile, URL)
                end else begin
                    // 襍ｷ蜍輔ヱ繝ｩ繝｡繝ｼ繧ｿ莉倥″蟇ｾ遲?/span>
                    path := '';
                    params := TStringList.Create;
                    try
                        params.Delimiter := ' ';
                        params.DelimitedText := Setting.URLAppFile;
                        for i := 0 to params.Count - 1 do begin
                            path := TrimLeft(path + ' ' + params[i]);
                            if (FileExists(path)) then begin
                                arg := '';
                                for j := i + 1 to params.Count - 1 do begin
                                    arg := arg + ' ' + params[j];
                                end;
                                break;
                            end;
                        end;
                        if i < params.Count then begin
                            GikoSys.CreateProcess(path, arg + ' ' + URL);
                        end else begin
                            HlinkNavigateString(nil, PWideChar(WideString(URL)));
                        end;
                    finally
                        params.Free;
                    end;
                end;
                        end else
                                HlinkNavigateString(nil, PWideChar(WideString(URL)));
        end;
end;

{!
\brief 譁?ｭ怜ｮ滉ｽ灘盾辣ｧ繧偵ョ繧ｳ繝ｼ繝?/span>
\param AStr 繝?さ繝ｼ繝峨☆繧区枚蟄怜?
\return     繝?さ繝ｼ繝峨＆繧後◆譁?ｭ怜?
}
function TGikoSys.HTMLDecode(const AStr: String): String;
var
        Sp, Rp, Cp, Tp: PChar;
        S: String;
        I, Code: Integer;
        Num: Boolean;
begin
        SetLength(Result, Length(AStr));
        Sp := PChar(AStr);
        Rp := PChar(Result);
        //Cp := Sp;
        try
                while Sp^ <> #0 do begin
                        case Sp^ of
                                '&': begin
                                                         //Cp := Sp;
                                                         Inc(Sp);
                                                         case Sp^ of
                                                                 'a': if AnsiStrPos(Sp, 'amp;') = Sp then
                                                                                        begin
                                                                                                Inc(Sp, 3);
                                                                                                Rp^ := '&';
                                                                                        end;
                                                                 'l',
                                                                 'g': if (AnsiStrPos(Sp, 'lt;') = Sp) or (AnsiStrPos(Sp, 'gt;') = Sp) then
                                                                                        begin
                                                                                                Cp := Sp;
                                                                                                Inc(Sp, 2);
                                                                                                while (Sp^ <> ';') and (Sp^ <> #0) do
                                                                                                        Inc(Sp);
                                                                                                if Cp^ = 'l' then
                                                                                                        Rp^ := '<'
                                                                                                else
                                                                                                        Rp^ := '>';
                                                                                        end;
                                                                 'q': if AnsiStrPos(Sp, 'quot;') = Sp then
                                                                                        begin
                                                                                                Inc(Sp,4);
                                                                                                Rp^ := '"';
                                                                                        end;
                                                                 '#': begin
                                                                                                Tp := Sp;
                                                                                                Inc(Tp);
                                                                                                Num := IsNumeric(Copy(Tp, 1, 1));
                                                                                                while (Sp^ <> ';') and (Sp^ <> #0) do begin
                                                                                                        if (Num) and (not IsNumeric(Copy(Sp, 1, 1))) then
                                                                                                                Break;
                                                                                                        Inc(Sp);
                                                                                                end;
                                                                                                SetString(S, Tp, Sp - Tp);
                                                                                                Val(S, I, Code);
                                                                                                Rp^ := Chr((I));
                                                                                        end;
                                                         //      else
                                                                         //raise EConvertError.CreateFmt(sInvalidHTMLEncodedChar,
                                                                                 //[Cp^ + Sp^, Cp - PChar(AStr)])
                                                         end;
                                         end
                        else
                                Rp^ := Sp^;
                        end;
                        Inc(Rp);
                        Inc(Sp);
                end;
        except
//              on E:EConvertError do
//                      raise EConvertError.CreateFmt(sInvalidHTMLEncodedChar,
//                              [Cp^ + Sp^, Cp - PChar(AStr)])
        end;
        SetLength(Result, Rp - PChar(Result));
end;

{!
\brief HTML 縺ｮ繧｢繝ｳ繧ｫ繝ｼ繧ｿ繧ｰ縺九ｉ URL 繧貞叙蠕?/span>
\param s URL 繧貞叙蠕励☆繧 HTML
\return  蜿門ｾ励＠縺 URL
}
function TGikoSys.GetHRefText(s: string): string;
var
        Index: Integer;
        Index2: Integer;
begin
        Result := '';
        s := Trim(s);
        if s = '' then
                Exit;

        Index := AnsiPos('href', LowerCase(s));
        if Index = 0 then
                Exit;
        s := Trim(Copy(s, Index + 4, Length(s)));
        s := Trim(Copy(s, 2, Length(s)));

        //蟋九ａ縺ｮ譁?ｭ励′'"'縺ｪ繧牙叙繧企勁縺?/span>
        //if Copy(s, 1, 1) = '"' then begin
    if s[1]  = '"' then begin
                s := Trim(Copy(s, 2, Length(s)));
        end;

        Index := AnsiPos('"', s);
        if Index <> 0 then begin
                //'"'縺ｾ縺ｧURL縺ｨ縺吶ｋ
                s := Copy(s, 1, Index - 1);
        end else begin
                //'"'縺檎┌縺代ｌ縺ｰ繧ｹ繝壹?繧ｹ縺?quot;>"縺ｮ譌ｩ縺?婿縺ｾ縺ｧ繧旦RL縺ｨ縺吶ｋ
                Index := AnsiPos(' ', s);
                Index2 := AnsiPos('>', s);
                if Index = 0 then
                        Index := Index2;
                if Index > Index2 then
                        Index := Index2;
                if Index <> 0 then
                        s := Copy(s, 1, Index - 1)
                else
                        //縺薙ｌ莉･荳翫ｂ縺?衍繧峨ｓ縺ｬ
                        ;
        end;
        Result := Trim(s);
end;

{!
\brief 繝帙せ繝亥錐縺鯉ｼ抵ｽ?ｽ医°縺ｩ縺?°繝√ぉ繝?け縺吶ｋ
\param Host 繝√ぉ繝?け縺吶ｋ繝帙せ繝亥錐
\return     2縺｡繧?ｓ縺ｭ繧九?繝帙せ繝亥錐縺ｪ繧 True
}
function TGikoSys.Is2chHost(Host: string): Boolean;
const
        HOST_NAME: array[0..1] of string = ('2ch.net', 'bbspink.com');
var
        i: Integer;
//      Len: Integer;
begin
        Result := False;
        if RightStr( Host, 1 ) = '/' then
                Host := Copy( Host, 1, Length( Host ) - 1 );
        OutputDebugString(pchar(HOST_NAME[0]));
        for i := 0 to Length(HOST_NAME) - 1 do begin
//              Len := Length(HOST_NAME[i]);
                if (AnsiPos(HOST_NAME[i], Host) > 0) and
                        (AnsiPos(HOST_NAME[i], Host) = (Length(Host) - Length(HOST_NAME[i]) + 1)) then begin
                        Result := True;
                        Exit;
                end;
        end;
end;

{!
\brief 2縺｡繧?ｓ縺ｭ繧句ｽ｢蠑上? URL 繧貞?隗｣
\param url      2縺｡繧?ｓ縺ｭ繧句ｽ｢蠑上? URL
\param path     test/read.cgi 縺ｪ縺ｩ縺ｮ荳ｭ髢薙ヱ繧ｹ(ParseURI 縺九ｉ蠕励ｋ)
\param document index.html 縺ｪ縺ｩ縺ｮ繝峨く繝･繝｡繝ｳ繝亥錐(ParseURI 縺九ｉ蠕励ｋ)
\param BBSID    OUT:BBSID 縺瑚ｿ斐ｋ(ex. giko)
\param BBSKey   OUT:繧ｹ繝ｬ繝?ラ繧ｭ繝ｼ縺瑚ｿ斐ｋ(ex. 10000000000)
\return 2縺｡繧?ｓ縺ｭ繧九? URL 縺ｨ縺励※蛻?ｧ｣縺ｧ縺阪◆縺ｪ繧 True
}
function TGikoSys.Parse2chURL(const url: string; const path: string; const document: string; var BBSID: string; var BBSKey: string): Boolean;
var
        Index: Integer;
        s: string;
        SList: TStringList;
begin
        BBSID := '';
        BBSKey := '';
        Result := False;

        Index := AnsiPos(READ_PATH, path);
        if Index <> 0 then begin
                s := Copy(path, Index + Length(READ_PATH), Length(path));
    end else begin
        Index := AnsiPos(HTML_READ_PATH, path);
        if Index <> 0 then begin
            s := Copy(path, Index + Length(HTML_READ_PATH), Length(path));
        end;
    end;
    if Index <> 0 then begin
                if (Length(s) > 0) and (s[1] = '/') then
                        Delete(s, 1, 1);
                BBSID := GetTokenIndex(s, '/', 0);
                BBSKey := GetTokenIndex(s, '/', 1);
                if BBSKey = '' then
                        BBSKey := Document;
                Result := (BBSID <> '') or (BBSKey <> '');
                Exit;
        end;
        Index := AnsiPos(KAKO_PATH, path);
        if Index <> 0 then begin
                s := Copy(path, 2, Length(path));
                BBSID := GetTokenIndex(s, '/', 0);
                if (BBSID = 'log') and (GetTokenIndex(s, '/', 2) = 'kako') then
                        BBSID := GetTokenIndex(s, '/', 1);
                BBSKey := ChangeFileExt(Document, '');
                Result := (BBSID <> '') or (BBSKey <> '');
                Exit;
        end;
        Index := AnsiPos('read.cgi?', URL);
        if Index <> 0 then begin
                SList := TStringList.Create;
                try
                        try
//                              s := HTMLDecode(Document);
                                ExtractHTTPFields(['?', '&'], [], PChar(URL), SList, False);
                                BBSID := SList.Values['bbs'];
                                BBSKey := SList.Values['key'];
                                Result := (BBSID <> '') or (BBSKey <> '');
                                Exit;
                        except
                                Exit;
                        end;
                finally
                        SList.Free;
                end;
        end;
end;

{!
\brief 2ch 蠖｢蠑上? URL 縺九ｉ繝ｬ繧ｹ逡ｪ繧貞叙蠕?/span>
\param URL    2縺｡繧?ｓ縺ｭ繧句ｽ｢蠑上? URL
\param stRes  OUT:髢句ｧ九Ξ繧ｹ逡ｪ縺瑚ｿ斐ｋ
\param endRes OUT:邨ゆｺ?Ξ繧ｹ逡ｪ縺瑚ｿ斐ｋ

http://2ch.net/荳ｭ逡･/32-50 \n
縺ｮ蝣ｴ蜷 stRef = 32, endRes = 50 縺ｫ縺ｪ繧?/span>
}
procedure TGikoSys.GetPopupResNumber(URL : string; var stRes, endRes : Int64);
const
    START_NAME : array[0..1] of String = ('st=', 'start=');
    END_NAME : array[0..1] of String = ('to=', 'end=');
    RES_NAME : array[0..0] of String = ('res=');
var
        buf : String;
        convBuf : String;
        ps : Int64;
        pch : PChar;
    bufList : TStringList;
    i, j, idx : Integer;
begin
        URL := Trim(LowerCase(URL));
    for i := 0 to Length(START_NAME) -1 do begin
        idx := AnsiPos(START_NAME[i], URL);
        if (idx <> 0) then begin
            break;
        end;
        idx := AnsiPos(END_NAME[i], URL);
        if (idx <> 0) then begin
            break;
        end;

    end;

    if (idx <> 0) then begin
        idx := AnsiPos('?', URL);
        if (idx = 0) then begin
            idx := LastDelimiter('/', URL);
        end;
        stRes := 0;
        endRes := 0;
        bufList := TStringList.Create();
        try
            bufList.Delimiter := '&';
            bufList.DelimitedText := Copy(URL, idx + 1, Length(URL));
            for  i := 0 to bufList.Count - 1 do begin
                convBuf := '';
                // 髢句ｧ九Ξ繧ｹ逡ｪ縺ｮ讀懃ｴ｢
                if (stRes = 0) then begin
                    for j := 0 to Length(START_NAME) - 1 do begin
                        idx := AnsiPos(START_NAME[j], bufList[i]);
                        if (idx = 1) then begin
                            convBuf := Copy(bufList[i], idx + Length(START_NAME[j]), Length(bufList[i]));
                            stRes := StrToInt64Def( convBuf, 0 );
                            break;
                        end;
                    end;
                end;
                // 邨ゆｺ?Ξ繧ｹ逡ｪ縺ｮ讀懃ｴ｢
                if (convBuf = '') and (endRes = 0) then begin
                    for j := 0 to Length(END_NAME) - 1 do begin
                        idx := AnsiPos(END_NAME[j], bufList[i]);
                        if (idx = 1) then begin
                            convBuf := Copy(bufList[i], idx + Length(END_NAME[j]), Length(bufList[i]));
                            endRes := StrToInt64Def( convBuf, 0 );
                            break;
                        end;
                    end;
                end;
                // 繝ｬ繧ｹ逡ｪ縺ｮ讀懃ｴ｢
                if ((stRes = 0) and (endRes = 0) and (convBuf = '')) then begin
                  for j := 0 to Length(RES_NAME) - 1 do begin
                      idx := AnsiPos(RES_NAME[j], bufList[i]);
                      if (idx = 1) then begin
                          convBuf := Copy(bufList[i], idx + Length(RES_NAME[j]), Length(bufList[i]));
                          stRes := StrToInt64Def( convBuf, 0 );
                          endRes := stRes;
                          break;
                      end;
                  end;
                end;
            end;

            if (stRes <> 0) and (endRes = 0) then begin
                        endRes := stRes + MAX_POPUP_RES;
                end else if (stRes = 0) and (endRes <> 0) then begin
                stRes := endRes - MAX_POPUP_RES;
                        if stRes < 1 then begin
                                stRes := 1;
                end;
            end;
        finally
            bufList.clear;
            bufList.free;
        end;
    end else if ( AnsiPos('.html',URL) <> Length(URL) -4 ) and ( AnsiPos('.htm',URL) <> Length(URL) -3 ) then begin
                buf := Copy(URL, LastDelimiter('/',URL)+1,Length(URL)-LastDelimiter('/',URL)+1);
                if  Length(buf) > 0 then begin
                        if AnsiPos('-', buf) = 1 then begin
                                stRes := 0;
                                Delete(buf,1,1);
                                ps := 0;
                                pch := PChar(buf);
                                while  ( ps < Length(buf) )and ( pch[ps] >= '0' ) and ( pch[ps] <= '9' ) do Inc(ps);
                convBuf := Copy( buf, 1, ps );
                if convBuf <> '' then begin
                    endRes := StrToInt64Def(convBuf, 0);
                end;
                                if endRes <> 0 then begin
                                        stRes := endRes - MAX_POPUP_RES;
                                        if stRes < 1 then
                                                stRes := 1;
                                end;
                        end else begin
                                ps := 0;
                                pch := PChar(buf);
                                while  ( ps < Length(buf) )and ( pch[ps] >= '0' ) and ( pch[ps] <= '9' ) do Inc(ps);
                                try
                                        convBuf := Copy( buf, 1, ps );
                                        if convBuf <> '' then begin
                                                stRes := StrToInt64(convBuf);
                                                Delete(buf,1,ps+1);
                                                ps := 0;
                                                pch := PChar(buf);
                                                while  ( ps < Length(buf) )and ( pch[ps] >= '0' ) and ( pch[ps] <= '9' ) do Inc(ps);
                        convBuf := Copy( buf, 1, ps );
                        if convBuf <> '' then begin
                            endRes := StrToInt64Def(convBuf, 0);
                        end;
                                        end else begin
                                                stRes := 0;
                                        end;
                                except
                                        stRes := 0;
                                        endRes := 0;
                                end;
                        end;
                end;
        end;
end;

{!
\brief 2縺｡繧?ｓ縺ｭ繧句ｽ｢蠑上? URL 繧貞?隗｣
\param URL 2縺｡繧?ｓ縺ｭ繧句ｽ｢蠑上? URL
\return    蛻?ｧ｣縺輔ｌ縺溯ｦ∫ｴ?
}
function TGikoSys.Parse2chURL2(URL: string): TPathRec;
var
        i: Integer;
        s: string;
//      buf : String;
//      convBuf : String;
        wk: string;
        wkMin: Integer;
        wkMax: Integer;
        wkInt: Integer;
        RStart: Integer;
        RLength: Integer;
//      ps : Integer;
//      pch : PChar;
        SList: TStringList;
begin
        URL := Trim(LowerCase(URL));
        Result.FBBS := '';
        Result.FKey := '';
        Result.FSt := 0;
        Result.FTo := 0;
        Result.FFirst := False;
        Result.FStBegin := False;
        Result.FToEnd := False;
        Result.FDone := False;
        Result.FNoParam := False;

        wkMin := 0;
        wkMax := 1;
        if URL[length(URL)] = '\' then
                URL := URL + 'n';
        FAWKStr.RegExp := 'http://.+\.(2ch\.net|bbspink\.com)/';
        if FAWKStr.Match(FAWKStr.ProcessEscSeq(URL), RStart, RLength) <> 0 then begin
                s := Copy(URL, RStart + RLength - 1, Length(URL));

                //讓呎ｺ匁嶌蠑?/span>
                //譛?蠕後?l50, 10, 10-20, 10n, 10-20n, -10, 10-, 10n- 縺ｪ縺ｩ
                //http://xxx.2ch.net/test/read.cgi/bbsid/1000000000/
                FAWKStr.RegExp := '/test/read.(cgi|html)/.+/[0-9]+/?.*';
                if FAWKStr.Match(FAWKStr.ProcessEscSeq(s), RStart, RLength) > 0 then begin
                        s := Copy(s, 15, Length(s));

                        SList := TStringList.Create;
                        try
                                SList.Clear;
                                FAWKStr.RegExp := '/';
                                if FAWKStr.Split(FAWKStr.ProcessEscSeq(s), SList) >= 3 then begin
                                        Result.FBBS := SList[1];
                                        Result.FKey := SList[2];
                                        if SList.Count >= 4 then
                                                s := SList[3]
                                        else begin
                                                s := '';
                                                Result.FNoParam := true;
                                        end;
                                end else
                                        Exit;

                                SList.Clear;
                                FAWKStr.LineSeparator := mcls_CRLF;
                                FAWKStr.RegExp := '-';
                                if FAWKStr.Split(FAWKStr.ProcessEscSeq(s), SList) = 0 then begin
                                        Result.FFirst := True;
                                end else begin
                                        FAWKStr.RegExp := 'l[0-9]+';
                                        if FAWKStr.Match(FAWKStr.ProcessEscSeq(s), RStart, RLength) > 0 then begin
                                                Result.FFirst := True;
                                        end else begin
                                                for i := 0 to SList.Count - 1 do begin
                                                        if Trim(SList[i]) = '' then begin
                                                                if i = 0 then
                                                                        Result.FStBegin := True;
                                                                if i = (SList.Count - 1) then
                                                                        Result.FToEnd := True;
                                                        end else if IsNumeric(SList[i]) then begin
                                                                wkInt := StrToInt(SList[i]);
                                                                wkMax := Max(wkMax, wkInt);
                                                                if wkMin = 0 then
                                                                        wkMin := wkInt
                                                                else
                                                                        wkMin := Min(wkMin, wkInt);
                                                        end else if Trim(SList[i]) = 'n' then begin
                                                                Result.FFirst := True;
                                                        end else begin
                                                                FAWKStr.RegExp := '^n[0-9]+$|^[0-9]+n$';
                                                                if FAWKStr.Match(FAWKStr.ProcessEscSeq(SList[i]), RStart, RLength) > 0 then begin
                                                                        if Copy(SList[i], 1, 1) = 'n' then
                                                                                wkInt := StrToInt(Copy(SList[i], 2, Length(SList[i])))
                                                                        else
                                                                                wkInt := StrToInt(Copy(SList[i], 1, Length(SList[i]) - 1));
                                                                        Result.FFirst := True;
                                                                        wkMax := Max(wkMax, wkInt);
                                                                        if wkMin = 1 then
                                                                                wkMin := wkInt
                                                                        else
                                                                                wkMin := Min(wkMin, wkInt);
                                                                end;
                                                        end;
                                                end;
                                                if Result.FStBegin and (not Result.FToEnd) then
                                                        Result.FSt := wkMin
                                                else if (not Result.FStBegin) and Result.FToEnd then
                                                        Result.FTo := wkMax
                                                else if (not Result.FStBegin) and (not Result.FToEnd) then begin
                                                        Result.FSt := wkMin;
                                                        Result.FTo := wkMax;
                                                end;
                                                //Result.FSt := wkMin;
                                                //Result.FTo := wkMax;
                                        end;
                                end;
                        finally
                                SList.Free;
                        end;
                        Result.FDone := True;
                        Exit;
                end;

                //譁ｰkako譖ｸ蠑?/span>
                //http://server.2ch.net/ITA_NAME/kako/1000/10000/1000000000.html
                FAWKStr.RegExp := '/.+/kako/[0-9]+/[0-9]+/[0-9]+\.html';
                if FAWKStr.Match(FAWKStr.ProcessEscSeq(s), RStart, RLength) > 0 then begin
                        SList := TStringList.Create;
                        try
                                SList.Clear;
                                FAWKStr.RegExp := '/';
                                if FAWKStr.Split(FAWKStr.ProcessEscSeq(s), SList) >= 6 then begin
                                        Result.FBBS := SList[1];
                                        Result.FKey := ChangeFileExt(SList[5], '');
                                        Result.FFirst := True;
                                end else
                                        Exit;
                        finally
                                SList.Free;
                        end;
                        Result.FDone := True;
                        Exit;
                end;

                //譌ｧkako譖ｸ蠑?/span>
                //http://server.2ch.net/ITA_NAME/kako/999/999999999.html
                FAWKStr.RegExp := '/.+/kako/[0-9]+/[0-9]+\.html';
                if FAWKStr.Match(FAWKStr.ProcessEscSeq(s), RStart, RLength) > 0 then begin
                        SList := TStringList.Create;
                        try
                                SList.Clear;
                                FAWKStr.RegExp := '/';
                                if FAWKStr.Split(FAWKStr.ProcessEscSeq(s), SList) >= 5 then begin
                                        Result.FBBS := SList[1];
                                        Result.FKey := ChangeFileExt(SList[4], '');
                                        Result.FFirst := True;
                                end else
                                        Exit;
                        finally
                                SList.Free;
                        end;
                        Result.FDone := True;
                        Exit;
                end;

                //log蜿翫?log2譖ｸ蠑?/span>
                //http://server.2ch.net/log/ITA_NAME/kako/999/999999999.html
                //http://server.2ch.net/log2/ITA_NAME/kako/999/999999999.html
                FAWKStr.RegExp := '/log2?/.+/kako/[0-9]+/[0-9]+\.html';
                if FAWKStr.Match(FAWKStr.ProcessEscSeq(s), RStart, RLength) > 0 then begin
                        SList := TStringList.Create;
                        try
                                SList.Clear;
                                FAWKStr.RegExp := '/';
                                if FAWKStr.Split(FAWKStr.ProcessEscSeq(s), SList) >= 6 then begin
                                        Result.FBBS := SList[2];
                                        Result.FKey := ChangeFileExt(SList[5], '');
                                        Result.FFirst := True;
                                end else
                                        Exit;
                        finally
                                SList.Free;
                        end;
                        Result.FDone := True;
                        Exit;
                end;


                //譌ｧURL譖ｸ蠑?/span>
                //http://server.2ch.net/test/read.cgi?bbs=ITA_NAME&key=1000000000&st=1&to=5&nofirst=true
                FAWKStr.RegExp := '/test/read\.cgi\?';
                if FAWKStr.Match(FAWKStr.ProcessEscSeq(s), RStart, RLength) > 0 then begin
                        s := Copy(s, 16, Length(s));
                        SList := TStringList.Create;
                        try
                                SList.Clear;
                                FAWKStr.RegExp := '&';
                                if FAWKStr.Split(FAWKStr.ProcessEscSeq(s), SList) >= 2 then begin
                                        Result.FFirst := True;
                                        for i := 0 to SList.Count - 1 do begin
                                                if Pos('bbs=', SList[i]) = 1 then begin
                                                        Result.FBBS := Copy(SList[i], 5, Length(SList[i]));
                                                end else if Pos('key=', SList[i]) = 1 then begin
                                                        Result.FKey := Copy(SList[i], 5, Length(SList[i]));
                                                end else if Pos('st=', SList[i]) = 1 then begin
                                                        wk := Copy(SList[i], 4, Length(SList[i]));
                                                        if IsNumeric(wk) then
                                                                Result.FSt := StrToInt(wk)
                                                        else if wk = '' then
                                                                Result.FStBegin := True;
                                                end else if Pos('to=', SList[i]) = 1 then begin
                                                        wk := Copy(SList[i], 4, Length(SList[i]));
                                                        if IsNumeric(wk) then
                                                                Result.FTo := StrToInt(wk)
                                                        else if wk = '' then
                                                                Result.FToEnd := True;
                                                end else if Pos('nofirst=', SList[i]) = 1 then begin
                                                        Result.FFirst := False;
                                                end;
                                        end;
                                end else
                                        Exit;
                        finally
                                SList.Free;
                        end;

                        if (Result.FBBS <> '') and (Result.FKey <> '') then begin
                                Result.FDone := True;
                        end;
                        Exit;
                end;
        end;
end;

{!
\brief URI 繧貞?隗｣
\param URL      蛻?ｧ｣縺吶ｋ URI
\param Protocol OUT:繝励Ο繝医さ繝ｫ縺瑚ｿ斐ｋ(ex. http)
\param Host     OUT:繝帙せ繝医′霑斐ｋ(ex. hoge.com)
\param Path     OUT:荳ｭ髢薙ヱ繧ｹ縺瑚ｿ斐ｋ(ex. test/read.cgi)
\param Document OUT:繝峨く繝･繝｡繝ｳ繝亥錐縺瑚ｿ斐ｋ(ex. index.html)
\param Port     OUT:繝昴?繝医′霑斐ｋ(ex. 8080)
\param Bookmark OUT:繝悶ャ繧ｯ繝槭?繧ｯ(?)縺瑚ｿ斐ｋ
}
procedure TGikoSys.ParseURI(const URL : string; var Protocol, Host, Path, Document, Port, Bookmark: string);
var
        URI: TIdURI;
begin
        Protocol := '';
        Host := '';
        Path := '';
        Document := '';
        Port := '';
        Bookmark := '';
        URI := TIdURI.Create(URL);
        try
                Protocol := URI.Protocol;
                Host := URI.Host;
                Path := URI.Path;
                Document := URI.Document;
                Port := URI.Port;
                Bookmark := URI.Bookmark;
        finally
                URI.Free;
        end;
end;

{!
\brief 繧ｮ繧ｳ繝翫ン縺ｮ繝舌?繧ｸ繝ｧ繝ｳ繧貞叙蠕?/span>
\return 繝舌?繧ｸ繝ｧ繝ｳ縺ｮ荳 2 譯?dwFileVersionLS)
}
function TGikoSys.GetVersionBuild: Integer;
var
        FixedFileInfo: PVSFixedFileInfo;
        VersionHandle, VersionSize: DWORD;
        pVersionInfo: Pointer;
        ItemLen : UInt;
        AppFile: string;
begin
        Result := 0;
        AppFile := Application.ExeName;
        VersionSize := GetFileVersionInfoSize(pChar(AppFile), VersionHandle);
        if VersionSize = 0 then
                Exit;
        GetMem(pVersionInfo, VersionSize);
        try
                if GetFileVersionInfo(PChar(AppFile),VersionHandle,VersionSize, pVersionInfo) then
                        if VerQueryValue(pVersionInfo, '\', Pointer(FixedFileInfo), ItemLen) then
                                Result := LOWORD(FixedFileInfo^.dwFileVersionLS);
        finally
                FreeMem(pVersionInfo, VersionSize);
        end;
end;

{!
\brief 繧ｹ繝ｬ繝?ラ URL 縺ｮ豁｣隕丞喧
\param inURL 豁｣隕丞喧縺吶ｋ繧ｹ繝ｬ繝?ラ URL
\return      豁｣隕丞喧縺輔ｌ縺溘せ繝ｬ繝?ラ URL

繧ｹ繝ｬ繝?ラ URL 繧偵ぐ繧ｳ繝翫ン縺ｮ荳ｭ縺ｧ荳?諢上↑繧ゅ?縺ｫ豁｣隕丞喧縺励∪縺吶??/span>
荳?諢上↑ URL 縺ｫ縺吶ｋ莠九〒縲ゞRL 縺九ｉ繧ｹ繝ｬ繝?ラ繧貞ｰ弱″蜃ｺ縺吩ｽ懈･ｭ繧呈怙驕ｩ蛹悶＠縺ｾ縺吶??n
豁｣隕丞喧縺ｮ譁ｹ驥昴→縺励※縲√し繧､繝医′謗ｨ螂ｨ縺吶ｋ繝?ヵ繧ｩ繝ｫ繝医? URL 縺ｫ縺ｪ繧九ｈ縺?↓蠢?′縺代∪縺吶??/span>
(1-1000 縺ｮ繧医≧縺ｪ雋?闕ｷ繧偵°縺代ｋ繧ゅ?縺ｫ縺ｯ縺励↑縺?％縺ｨ)

萓?豁｣隕丞喧蜑?:\n
http://荳ｭ逡･/ \n
http://荳ｭ逡･/20-100

(豁｣隕丞喧蠕?:\n
http://荳ｭ逡･/l50
}
function        TGikoSys.GetBrowsableThreadURL(
        inURL : string
) : string;
var
        threadItem      : TThreadItem;
        boardPlugIn     : TBoardPlugIn;
    board               : TBoard;
        i                                               : Integer;
begin

        //===== 繝励Λ繧ｰ繧､繝ｳ
        try
                for i := Length( BoardGroups ) - 1 downto 1 do begin
                        if Assigned( Pointer( BoardGroups[i].BoardPlugIn.Module ) ) then begin
                                if BoardGroups[i].BoardPlugIn.AcceptURL( inURL ) = atThread then begin
                    board := BBSsFindBoardFromURL( BoardGroups[i].BoardPlugIn.ExtractBoardURL(inURL) );
                                        if board <> nil then begin
                                                boardPlugIn := BoardGroups[i].BoardPlugIn;
                                                threadItem      := TThreadItem.Create( boardPlugIn, board, inURL );
                                                Result                  := threadItem.URL;
                                                threadItem.Free;

                                        end;
                                        Exit;
                                end;
                        end;
                end;
        except
                // exception 縺檎匱逕溘＠縺溷?ｴ蜷医?蜀?Κ蜃ｦ逅?↓莉ｻ縺帙◆縺??縺ｧ縺薙％縺ｧ縺ｯ菴輔ｂ縺励↑縺?/span>
        end;

        if Length( Result ) = 0 then
                Result := GikoSys.Get2chBrowsableThreadURL( inURL );

end;

{!
\brief 繧ｹ繝ｬ繝?ラ URL 繧呈攸 URL 縺ｫ螟画鋤
\param inURL 繧ｹ繝ｬ繝?ラ URL
\return      譚ｿ URL
}
function        TGikoSys.GetThreadURL2BoardURL(
        inURL : string
) : string;
var
        threadItem      : TThreadItem;
        boardPlugIn     : TBoardPlugIn;
    board               : TBoard;
        i                                               : Integer;
begin

        //===== 繝励Λ繧ｰ繧､繝ｳ
        try
                for i := Length( BoardGroups ) - 1 downto 1 do begin
                        if Assigned( Pointer( BoardGroups[i].BoardPlugIn.Module ) ) then begin
                                if BoardGroups[i].BoardPlugIn.AcceptURL( inURL ) = atThread then begin
                    board               := BBSsFindBoardFromURL(BoardGroups[i].BoardPlugIn.ExtractBoardURL(inURL));
                                        boardPlugIn := BoardGroups[i].BoardPlugIn;
                                        threadItem      := TThreadItem.Create( boardPlugIn, board, inURL );
                                        Result                  := BoardGroups[i].BoardPlugIn.GetBoardURL( Longword( threadItem ) );
                                        threadItem.Free;

                                        Break;
                                end;
                        end;
                end;
        except
                // exception 縺檎匱逕溘＠縺溷?ｴ蜷医?蜀?Κ蜃ｦ逅?↓莉ｻ縺帙◆縺??縺ｧ縺薙％縺ｧ縺ｯ菴輔ｂ縺励↑縺?/span>
        end;

        if Length( Result ) = 0 then
                Result := GikoSys.Get2chThreadURL2BoardURL( inURL );

end;

{!
\brief 2ch逕ｨ:繧ｹ繝ｬ繝?ラ URL 繧呈攸 URL 縺ｫ螟画鋤
\param inURL 繧ｹ繝ｬ繝?ラ URL
\return      譚ｿ URL
\see TGikoSys.GetThreadURL2BoardURL
}
function        TGikoSys.Get2chThreadURL2BoardURL(
        inURL : string
) : string;
var
        Protocol, Host, Path, Document, Port, Bookmark : string;
        BBSID, BBSKey : string;
        foundPos                        : Integer;
begin

        ParseURI( inURL, Protocol, Host, Path, Document, Port, Bookmark );
        Parse2chURL( inURL, Path, Document, BBSID, BBSKey );

        foundPos := Pos( '/test/read.cgi', inURL );
        if {(Is2chHost(Host)) and} (foundPos > 0) then
                Result := Copy( inURL, 1, foundPos ) + BBSID + '/'
        else
                Result := Protocol + '://' + Host + '/' + BBSID + '/';

end;

{!
\brief 2ch逕ｨ:繧ｹ繝ｬ繝?ラ URL 縺ｮ豁｣隕丞喧
\param inURL 豁｣隕丞喧縺吶ｋ繧ｹ繝ｬ繝?ラ URL
\return      豁｣隕丞喧縺輔ｌ縺溘せ繝ｬ繝?ラ URL
\see TGikoSys.GetBrowsableThreadURL
}
function        TGikoSys.Get2chBrowsableThreadURL(
        inURL                   : string
) : string;
var
        Protocol, Host, Path, Document, Port, Bookmark : string;
        BBSID, BBSKey : string;
        foundPos        : Integer;
begin

//      if Pos( KAKO_PATH, inURL ) > 0 then begin
//              Result := inURL;
//      end else begin
                ParseURI( inURL, Protocol, Host, Path, Document, Port, Bookmark );
                Parse2chURL( inURL, Path, Document, BBSID, BBSKey );
                foundPos := Pos( '/test/read.cgi', inURL ) - 1;

                if Is2chHost( Host ) then begin
                        Result := Protocol + '://' + Host +
                                READ_PATH + BBSID + '/' + BBSKey + '/l50';
                end else begin
                        if foundPos > 0 then
                                Result := Copy( inURL, 1, foundPos ) +
                                        OLD_READ_PATH + 'bbs=' + BBSID + '&key=' + BBSKey + '&ls=50'
                        else
                                Result := Protocol + '://' + Host +
                                        OLD_READ_PATH + 'bbs=' + BBSID + '&key=' + BBSKey + '&ls=50';
                end;
//      end;

end;

{!
\brief 2ch逕ｨ:譚ｿ URL 縺九ｉ繧ｹ繝ｬ繝?ラ URL 繧剃ｽ懈?
\param inBoard 譚ｿ URL
\param inKey   繧ｹ繝ｬ繝?ラ繧ｭ繝ｼ(ex. 1000000000)
\return        繧ｹ繝ｬ繝?ラ URL
}
function        TGikoSys.Get2chBoard2ThreadURL(
        inBoard : TBoard;
        inKey           : string
) : string;
var
        server  : string;
begin

        server := UrlToServer( inBoard.URL );
        //if Is2chHost( server ) then
        if inBoard.Is2ch then
                Result := server + 'test/read.cgi/' + inBoard.BBSID + '/' + inKey + '/l50'
        else
                Result := server + 'test/read.cgi?bbs=' + inBoard.BBSID + '&key=' + inKey + '&ls=50';

end;

{!
\brief 繝懊?繝峨ヵ繧｡繧､繝ｫ蛻玲嫌

蛻玲嫌縺輔ｌ縺 BBS(繝懊?繝? 縺ｯ BBSs 縺ｫ蜈･繧翫∪縺吶??/span>
}
procedure TGikoSys.ListBoardFile;
var
        boardFileList   : TStringList;
        i, l                    : Integer;
    sCategory       : TCategory;
begin
        // BBS 縺ｮ髢区叛
        try
          for i := 0 to Length( BBSs ) - 1 do
                BBSs[ i ].Free;
        except
        end;
        SetLength( BBSs, 0 );

        l := 0;
        // 譚ｿ繝ｪ繧ｹ繝医?蛻玲嫌
        if FileExists( GikoSys.GetBoardFileName ) then begin
          SetLength( BBSs, l + 1 );
          BBSs[ l ]                             := TBBS.Create( GikoSys.GetBoardFileName );
          BBSs[ l ].Title       := '?偵■繧?ｓ縺ｭ繧?#39;;
                  Inc( l );
        end;

        if FileExists( GikoSys.GetCustomBoardFileName ) then begin
          SetLength( BBSs, l + 1 );
          BBSs[ l ]                             := TBBS.Create( GikoSys.GetCustomBoardFileName );
          BBSs[ l ].Title       := '縺昴?莉?#39;;
                  Inc( l );
        end;

        // Board 繝輔か繝ｫ繝?
        if DirectoryExists( GikoSys.Setting.GetBoardDir ) then begin
          BoardFileList := TStringList.Create;
          try
        BoardFileList.BeginUpdate;
                GikoSys.GetFileList( GikoSys.Setting.GetBoardDir, '*.txt', BoardFileList, True, True );
        BoardFileList.EndUpdate;
        SetLength( BBSs, l + BoardFileList.Count );
                for i := BoardFileList.Count - 1 downto 0 do begin
                  BBSs[ l ]                             := TBBS.Create( BoardFileList[ i ] );
                  BBSs[ l ].Title       := ChangeFileExt( ExtractFileName( BoardFileList[ i ] ), '' );
                  Inc( l );
                end;
          finally
                BoardFileList.Free;
          end;
        end;

    // 迚ｹ谿顔畑騾韮BS逕滓?
    // 譌｢縺ｫ蟄伜惠縺吶ｋ蝣ｴ蜷医?蜑企勁縺吶ｋ
    DestorySpecialBBS(BoardGroup.SpecialBBS);
    SpecialBBS := TBBS.Create('');
    SpecialBBS.Title := '迚ｹ谿顔畑騾?髱櫁｡ｨ遉ｺ)';
    sCategory := TCategory.Create;
    sCategory.No := 1;
    sCategory.Title := '迚ｹ谿顔畑騾?髱櫁｡ｨ遉ｺ)';
    SpecialBBS.Add(sCategory);
    BoardGroup.SpecialBoard := TSpecialBoard.Create(nil, 'http://localhost/gikonavi/special/index.html');
    BoardGroup.SpecialBoard.Title := '繧ｿ繝紋ｸ?隕ｧ';
    BoardGroup.SpecialBoard.IsThreadDatRead := True;
    sCategory.Add(BoardGroup.SpecialBoard);
end;

{!
\brief 繝懊?繝峨ヵ繧｡繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ
\param bbs 繝懊?繝峨ヵ繧｡繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ繧? BBS
}
procedure TGikoSys.ReadBoardFile( bbs : TBBS );
var
//      idx                                             : Integer;
        ini                                             : TMemIniFile;
        p : Integer;
        boardFile                       : TStringList;
        CategoryList    : TStringList;
        BoardList                       : TStringList;
        Category                        : TCategory;
        Board                                   : TBoard;
        inistr                          : string;
        tmpstring                       : string;
//      RoundItem                       : TRoundItem;

        i, iBound                       : Integer;
        j, jBound                       : Integer;
        k, kBound                       : Integer;
begin

        if not FileExists( bbs.FilePath ) then
                Exit;

        bbs.Clear;
        ini := TMemIniFile.Create('');
        boardFile := TStringList.Create;

        try
                boardFile.LoadFromFile( bbs.FilePath );

                ini.SetStrings( boardFile );
                CategoryList    := TStringList.Create;
                BoardList                       := TStringList.Create;
                try
                        ini.ReadSections( CategoryList );

                        iBound := CategoryList.Count - 1;
                        for i := 0 to iBound do begin
                                ini.ReadSection( CategoryList[i], BoardList );
                                Category                                := TCategory.Create;
                                Category.No                     := i + 1;
                                Category.Title  := CategoryList[i];

                                jBound := BoardList.Count - 1;
                                for j := 0 to jBound do begin
                                        Board := nil;
                                        inistr := ini.ReadString(CategoryList[i], BoardList[j], '');
                                        //'http://'繧貞性縺ｾ縺ｪ縺?枚蟄怜?縺ｮ譎ゅ?辟｡隕悶☆繧?/span>
                                        if (AnsiPos('http://', AnsiLowerCase(inistr)) = 0) then Continue;
                                        //===== 繝励Λ繧ｰ繧､繝ｳ
                                        try
                                                kBound := Length(BoardGroups) - 1;
                                                for k := 1 to kBound do begin  //0縺ｯ縲?縺｡繧?ｓ
                                                        if Assigned( Pointer( BoardGroups[k].BoardPlugIn.Module ) ) then begin
                                                                if BoardGroups[k].BoardPlugIn.AcceptURL( inistr ) = atBoard then begin
                                                                        if not BoardGroups[k].Find(inistr, p) then begin
                                                                                tmpstring := BoardGroups[k].BoardPlugIn.ExtractBoardURL( inistr );
                                                                                if AnsiCompareStr(tmpString, inistr) <> 0 then begin
                                                                                        if not BoardGroups[k].Find(tmpstring, p) then begin
                                                                                                try
                                                                                                        Board := TBoard.Create( BoardGroups[k].BoardPlugIn, tmpstring );
                                                                                                        BoardGroups[k].AddObject(tmpstring, Board);
                                                                                                        Category.Add(Board);
                                                                                                except
                                                                                                        //縺薙％縺ｫ譚･繧九→縺励◆繧隠oard縺ｮ菴懈?縺ｫ螟ｱ謨励＠縺溘→縺阪□縺九ｉBoard繧地il縺ｫ縺吶ｋ
                                                                                                        Board := nil;
                                                                                                end;
                                                                                        end else begin
                                                                                                Board := TBoard(BoardGroups[k].Objects[p]);
                                                                                                if Board.ParentCategory <> Category then
                                                                                                        Category.Add(Board);
                                                                                        end;
                                                                                end else begin
                                                                                        try
                                                                                                Board := TBoard.Create( BoardGroups[k].BoardPlugIn, tmpstring );
                                                                                                BoardGroups[k].AddObject(tmpstring, Board);
                                                                                                Category.Add(Board);
                                                                                        except
                                                                                                //縺薙％縺ｫ譚･繧九→縺励◆繧隠oard縺ｮ菴懈?縺ｫ螟ｱ謨励＠縺溘→縺阪□縺九ｉBoard繧地il縺ｫ縺吶ｋ
                                                                                                Board := nil;
                                                                                        end;
                                                                                end;
                                                                        end else begin
                                                                                Board := TBoard(BoardGroups[k].Objects[p]);
                                                                                if Board.ParentCategory <> Category then
                                                                                        Category.Add(Board);
                                                                        end;
                                                                        Break;
                                                                end;
                                                        end;
                                                end;
                                        except
                                                // exception 縺檎匱逕溘＠縺溷?ｴ蜷医?蜀?Κ蜃ｦ逅?↓莉ｻ縺帙◆縺??縺ｧ縺薙％縺ｧ縺ｯ菴輔ｂ縺励↑縺?/span>
                                        end;
                                        try
                                                if (Board = nil) then begin
                                                        if not BoardGroups[0].Find(inistr,p) then begin
                                                                Board := TBoard.Create( nil, inistr );
                                                                BoardGroups[0].AddObject(inistr, Board);
                                                                Category.Add(Board);
                                                        end else begin
                                                                Board := TBoard(BoardGroups[0].Objects[p]);
                                                                if Board.ParentCategory <> Category then
                                                                        Category.Add(Board);
                                                        end;
                                                end;

                                                if (Board.Multiplicity = 0) then begin
                                                        Board.BeginUpdate;
                                                        Board.No := j + 1;
                            Board.Multiplicity := 1;
                                                        Board.Title := BoardList[j];
                                                        Board.RoundDate := ZERO_DATE;
                                                        Board.LoadSettings;
                                                        Board.EndUpdate;
                                                end else begin
                                                        Board.No := j + 1;
                                                        Board.Multiplicity := Board.Multiplicity + 1;
                                                end;
                                        except
                                        end;
                                end;
                                bbs.Add( Category );
                        end;


                  //end;
                  bbs.IsBoardFileRead := True;
          finally
                BoardList.Free;
                CategoryList.Free;
          end;
  finally
        boardFile.Free;
        ini.Free;
  end;

end;

{!
\brief 蜷咲ｧｰ縺御ｸ肴?縺ｪ繧ｫ繝?ざ繝ｪ縺ｮ逕滓?
\return 逕滓?縺輔ｌ縺溘き繝?ざ繝ｪ
}
function        TGikoSys.GetUnknownCategory : TCategory;
const
        UNKNOWN_CATEGORY = '(蜷咲ｧｰ荳肴?)';
begin

        if Length( BBSs ) < 2 then begin
                Result := nil;
                Exit;
        end;

        Result := BBSs[ 1 ].FindCategoryFromTitle( UNKNOWN_CATEGORY );
        if Result = nil then begin
                Result                          := TCategory.Create;
                Result.Title    := UNKNOWN_CATEGORY;
                BBSs[ 1 ].Add( Result );
        end;

end;

{!
\brief 蜷咲ｧｰ縺御ｸ肴?縺ｪ BBS 縺ｮ逕滓?
\return 逕滓?縺輔ｌ縺 BBS
}
function        TGikoSys.GetUnknownBoard( inPlugIn : TBoardPlugIn; inURL : string ) : TBoard;
var
        category : TCategory;
const
        UNKNOWN_BOARD = '(蜷咲ｧｰ荳肴?)';
begin

        category := GetUnknownCategory;
        if category = nil then begin
                Result := nil;
        end else begin
                Result := category.FindBoardFromTitle( UNKNOWN_BOARD );
                if Result = nil then begin
                        Result                          := TBoard.Create( inPlugIn, inURL );
                        Result.Title    := UNKNOWN_BOARD;
                        category.Add( Result );
                end;
        end;

end;

//! Samba.ini
function TGikoSys.GetSambaFileName : string;
begin
        Result := Setting.GetSambaFileName;
end;
{!
\brief 蛻玲嫌縺輔ｌ縺溘Ξ繧ｹ逡ｪ蜿ｷ縺ｸ縺ｮ繧｢繝ｳ繧ｫ繝ｼ逕ｨHTML菴懈?
\param Numbers    蛻玲嫌縺輔ｌ縺溘Ξ繧ｹ逡ｪ蜿ｷ
\param ThreadItem 蛻玲嫌縺吶ｋ繧ｹ繝ｬ繝?ラ
\param limited    蛻玲嫌縺吶ｋ謨ｰ繧貞宛髯舌☆繧九↑繧?莉･荳?/span>
\return           蛻玲嫌縺輔ｌ縺溘Ξ繧ｹ繧｢繝ｳ繧ｫ繝ｼ
}
function TGikoSys.CreateResAnchor(
    var Numbers: TStringList; ThreadItem: TThreadItem;
    limited: Integer):string;
var
        i: integer;
    Res: TResRec;
    ResLink : TResLinkRec;
begin
    // body莉･螟悶?菴ｿ逕ｨ縺励↑縺??縺ｧ蛻晄悄蛹悶＠縺ｪ縺?/span>
    Res.FBody := '';
    Res.FType := glt2chNew;

        Result := '';
        if (Numbers <> nil) and (Numbers.Count > 0) then begin
        if (limited > 0) and (Numbers.Count > limited) then begin
            for i := Numbers.Count - limited to Numbers.Count - 1 do begin
                Res.FBody := Res.FBody + '&gt;' + Numbers[i] + ' ';
            end;
        end else begin
            for i := 0 to Numbers.Count - 1 do begin
                Res.FBody := Res.FBody + '&gt;' + Numbers[i] + ' ';
            end;
        end;
        ResLink.FBbs := ThreadItem.ParentBoard.BBSID;
        ResLink.FKey := ChangeFileExt(ThreadItem.FileName, '');
        HTMLCreater.ConvRes(@Res, @ResLink, false);
        Result := Res.FBody;
    end;
end;

{!
\brief 蜷後§謚慕ｨｿ ID 繧呈戟縺､繝ｬ繧ｹ繧貞?謖?/span>
\param AID        蛟倶ｺｺ繧堤音螳壹☆繧区兜遞ｿ ID
\param ThreadItem 蛻玲嫌縺吶ｋ繧ｹ繝ｬ繝?ラ
\param body       OUT:蛻玲嫌縺輔ｌ縺溘Ξ繧ｹ逡ｪ蜿ｷ縺瑚ｿ斐ｋ
}
procedure TGikoSys.GetSameIDRes(const AID : string; ThreadItem: TThreadItem;var body: TStringList);
var
        i: integer;
        ReadList: TStringList;
        Res: TResRec;
        boardPlugIn : TBoardPlugIn;

    procedure CheckSameID(const AID:String; const Target: String; no: Integer);
    var
        pos: Integer;
    begin
        pos := AnsiPos('id:', LowerCase(Target));
        if (pos > 0) then begin
            if(AnsiPos(AID, Copy(Target, pos-1, Length(Target))) > 0) then begin
                body.Add(IntToStr(no));
            end;
        end else begin
            if(AnsiPos(AID, Target) > 0) then begin
                body.Add(IntToStr(no));
            end;
        end;
    end;
begin
        if (not IsNoValidID(AID)) and
        (ThreadItem <> nil) and (ThreadItem.IsLogFile) then begin
                //if ThreadItem.IsBoardPlugInAvailable then begin
        if ThreadItem.ParentBoard.IsBoardPlugInAvailable then begin
                        //===== 繝励Λ繧ｰ繧､繝ｳ縺ｫ繧医ｋ陦ｨ遉ｺ
                        //boardPlugIn           := ThreadItem.BoardPlugIn;
            boardPlugIn         := ThreadItem.ParentBoard.BoardPlugIn;

                        for i := 0 to threadItem.Count - 1 do begin
                                // 繝ｬ繧ｹ
                                THTMLCreate.DivideStrLine(boardPlugIn.GetDat(DWORD( threadItem ), i + 1), @Res);
                CheckSameID(AID, Res.FDateTime, i+1);
                        end;
                end else begin
                        ReadList := TStringList.Create;
                        try
                                ReadList.LoadFromFile(ThreadItem.GetThreadFileName);
                                for i := 0 to ReadList.Count - 1 do begin
                                        THTMLCreate.DivideStrLine(ReadList[i], @Res);
                    CheckSameID(AID, Res.FDateTime, i+1);
                                end;
                        finally
                                ReadList.Free;
                        end;
                end;
        end;
end;

{!
\brief 蜷後§謚慕ｨｿ ID 繧呈戟縺､繝ｬ繧ｹ繧貞?謖?/span>
\param AIDNum     蛟倶ｺｺ繧堤音螳壹☆繧区兜遞ｿ ID
\param ThreadItem 蛻玲嫌縺吶ｋ繧ｹ繝ｬ繝?ラ
\param body       OUT:蛻玲嫌縺輔ｌ縺溘Ξ繧ｹ逡ｪ蜿ｷ縺瑚ｿ斐ｋ
}
procedure TGikoSys.GetSameIDRes(AIDNum : Integer; ThreadItem: TThreadItem;var body: TStringList);
var
        AID : String;
begin
    AID := GetResID(AIDNum, ThreadItem);
    if not IsNoValidID(AID) then begin
            GetSameIDRes(AID, ThreadItem, body);
        end;
end;
{!
\brief 謚慕ｨｿ ID 蜿門ｾ?/span>
\param AIDNum     謚慕ｨｿ 繝ｬ繧ｹ逡ｪ蜿ｷ
\param ThreadItem 謚慕ｨｿ繧ｹ繝ｬ繝?ラ
\param body       OUT:謚慕ｨｿID
}
function TGikoSys.GetResID(AIDNum: Integer; ThreadItem: TThreadItem): String;
var
        Res: TResRec;
        boardPlugIn : TBoardPlugIn;
begin
    Result := '';
        if (ThreadItem <> nil) and (ThreadItem.IsLogFile)
                and (AIDNum > 0) and (AIDNum <= ThreadItem.Count) then begin
                //if ThreadItem.IsBoardPlugInAvailable then begin
        if ThreadItem.ParentBoard.IsBoardPlugInAvailable then begin
                        //===== 繝励Λ繧ｰ繧､繝ｳ縺ｫ繧医ｋ陦ｨ遉ｺ
                        //boardPlugIn           := ThreadItem.BoardPlugIn;
            boardPlugIn         := ThreadItem.ParentBoard.BoardPlugIn;
                        THTMLCreate.DivideStrLine(boardPlugIn.GetDat(DWORD( threadItem ), AIDNum), @Res);
                end else begin
                        THTMLCreate.DivideStrLine( ReadThreadFile(ThreadItem.GetThreadFileName, AIDNum), @Res);
                end;
                Result := ExtructResID(Res.FDateTime);
        end;
end;
{!
\brief 繝ｬ繧ｹ縺ｮ譎ょ綾驛ｨ縺九ｉID繧呈歓蜃ｺ縺吶ｋ
\param ADateStr 譎ょ綾驛ｨ縺ｮ譁?ｭ怜?
\return     ID(ID縺ｨ縺ｿ縺ｪ縺帙ｋ驛ｨ蛻?′縺ｪ縺?→縺阪?遨ｺ譁?ｭ怜?)
}
function TGikoSys.ExtructResID(ADateStr: String): String;
var
    stlist : TStringList;
begin
    Result := '';
    if AnsiPos('id', AnsiLowerCase(ADateStr)) > 0 then begin
        Result := Copy(ADateStr, AnsiPos('id', AnsiLowerCase(ADateStr)), Length(ADateStr));
        if AnsiPos(' ', Result) > 0 then begin
            Result := Copy(Result, 1, AnsiPos(' ', Result) - 1);
        end;
        Result := ' ' + Result;
    end else begin
        stlist := TStringList.Create;
        try
            stList.Delimiter := ' ';
            stList.DelimitedText := ADateStr;
            // 譌･莉 譎ょ綾 ID 莉悶??縺ｨ蝗ｺ螳壹〒閠?∴繧?/span>
            if (stList.Count >= 3) then begin
                if Length(stList[3 - 1]) >= 7 then begin
                    Result := stList[3 - 1];
                end;
            end;
        finally
            stList.Free;
        end;
    end;
end;

{!
\brief 繧ｹ繝代Β:隱樊焚繧偵き繧ｦ繝ｳ繝?/span>
\param text      蜈?↓縺ｪ繧区枚遶?
\param wordCount OUT:繧ｫ繧ｦ繝ｳ繝医＆繧後◆蜊倩ｪ槭?荳?隕ｧ縺瑚ｿ斐ｋ
}
procedure TGikoSys.SpamCountWord( const text : string; wordCount : TWordCount );
begin

        if Setting.SpamFilterAlgorithm = gsfaNone then Exit;
        Bayesian.CountWord( text, wordCount );

end;

{!
\brief 繧ｹ繝代Β:蟄ｦ鄙堤ｵ先棡繧呈叛譽?/span>
\param wordCount 謾ｾ譽?☆繧句腰隱槭?荳?隕ｧ
\param isSpam    wordCount 縺後せ繝代Β縺ｨ縺励※蟄ｦ鄙偵＆繧後※縺?◆縺ｪ繧 True
\warning        蟄ｦ鄙呈ｸ医∩縺ｮ譁?ｫ?縺九←縺?°縺ｯ遒ｺ隱榊?譚･縺ｾ縺帙ｓ縲?n
                                        Learn 縺励※縺?↑縺?枚遶?繧 isSpam 繧帝俣驕輔∴縺ｦ謖?ｮ壹☆繧九→
                                        繝??繧ｿ繝吶?繧ｹ縺檎?ｴ謳阪＠縺ｾ縺吶??n
                                        蟄ｦ鄙呈ｸ医∩縺九←縺?°縺ｯ迢ｬ閾ｪ縺ｫ邂｡逅?＠縺ｦ縺上□縺輔＞縲?/span>

蜈ｨ縺ｦ縺ｮ蟄ｦ鄙堤ｵ先棡繧偵け繝ｪ繧｢縺吶ｋ繧上¢縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縲?n
wordCount 繧貞ｾ励◆譁?ｫ?縺ｮ蟄ｦ鄙堤ｵ先棡縺ｮ縺ｿ繧ｯ繝ｪ繧｢縺励∪縺吶??/span>

荳ｻ縺ｫ繧ｹ繝代Β縺ｨ繝上Β繧貞?繧頑崛縺医ｋ縺溘ａ縺ｫ Forget -> Learn 縺ｮ鬆?〒菴ｿ逕ｨ縺励∪縺吶??/span>
}
procedure TGikoSys.SpamForget( wordCount : TWordCount; isSpam : Boolean );
begin

        if Setting.SpamFilterAlgorithm = gsfaNone then Exit;
        Bayesian.Forget( wordCount, isSpam );

end;

{!
\brief 繧ｹ繝代Β:蟄ｦ鄙?/span>
\param wordCount 蟄ｦ鄙偵☆繧句腰隱槭?荳?隕ｧ
\param isSpam    繧ｹ繝代Β縺ｨ縺励※蟄ｦ鄙偵☆繧九↑繧 True
}
procedure TGikoSys.SpamLearn( wordCount : TWordCount; isSpam : Boolean );
begin

        if Setting.SpamFilterAlgorithm = gsfaNone then Exit;
        Bayesian.Learn( wordCount, isSpam );

end;

{!
\brief 繧ｹ繝代Β:譁?ｫ?繧定ｧ｣譫舌＠縲√せ繝代Β蠎ｦ謨ｰ繧貞ｾ励ｋ
\param text      蜈?↓縺ｪ繧区枚遶?
\param wordCount OUT:繧ｫ繧ｦ繝ｳ繝医＆繧後◆蜊倩ｪ槭?荳?隕ｧ縺瑚ｿ斐ｋ(SpamCountWord 縺ｨ蜷檎ｭ?
\return          0縲? 縺ｮ繧ｹ繝代Β蠎ｦ謨ｰ
}
function TGikoSys.SpamParse( const text : string; wordCount : TWordCount ) : Extended;
begin

        case Setting.SpamFilterAlgorithm of
        gsfaNone:                                                               Result := 0;
        gsfaPaulGraham:                                 Result := Bayesian.Parse( text, wordCount, gbaPaulGraham );
        gsfaGaryRobinson:                               Result := Bayesian.Parse( text, wordCount, gbaGaryRobinson );
        gsfaGaryRobinsonFisher: Result := Bayesian.Parse( text, wordCount, gbaGaryRobinsonFisher );
        else                                                                            Result := 0;
        end;

end;

{!
\brief 繝ｦ繝ｼ繧ｶ險ｭ螳壹? CSS 繧堤函謌?/span>
\return 逕滓?縺輔ｌ縺 CSS

[繝??繝ｫ]繝｡繝九Η繝ｼ-[繧ｪ繝励す繝ｧ繝ｳ]-[CSS 縺ｨ繧ｹ繧ｭ繝ｳ]繧ｿ繝悶?
[繝輔か繝ｳ繝医ｒ謖?ｮ咯, [閭梧勹濶ｲ繧呈欠螳咯 縺ｫ豐ｿ縺｣縺 CSS 繧堤函謌舌＠縺ｾ縺吶??/span>
}
function TGikoSys.SetUserOptionalStyle(): string;
begin
                Result := '';