//--------------------------------------------------------------------------------------------------
    // メインウィンドウ左側描画領域.
    // 検索条件などを指定する領域.
    private void drawMainLeftElem()
    {
        EditorGUILayout.BeginVertical( GUI.skin.box, GUILayout.Width( MAIN_LEFT_ELEM_WIDTH ) );

        this.searchType = ( SearchType )EditorGUILayout.EnumPopup( "検索タイプ", this.searchType );
        this.searchScope = ( SearchScope )EditorGUILayout.EnumPopup( "検索範囲", this.searchScope );
        this.wholeWord = EditorGUILayout.Toggle( "完全一致か否か.", this.wholeWord );
        if ( !this.wholeWord )
            this.caseSencitive = EditorGUILayout.Toggle( "大小文字一致比較.", this.caseSencitive );

        switch ( this.searchType ){
            case SearchType.Name: EditorGUILayout.LabelField( "Input ObjectName" );	break;
            case SearchType.Component: EditorGUILayout.LabelField( "Input ComponentName" ); break;
            default: break;
        }
        this.searchText = EditorGUILayout.TextField( this.searchText, GUI.skin.textField );

        if ( GUILayout.Button( "Search" ) ){
            Debug.Log( "捜索します." );
            this.search();
        }

        MyEditorLayout.space( 3 );
        MyEditorLayout.separatorLine( MAIN_LEFT_ELEM_WIDTH );
        this.dumpFoldout = EditorGUILayout.Foldout( this.dumpFoldout, "Show Dump Palameter" );
        if ( this.dumpFoldout )
            this.drawDumpPalameter();

        EditorGUILayout.EndVertical();
    }

		public IEnumerable<IDirectory> Directories(string filter, SearchScope scope)
		{
			Contract.Requires(filter != null);
			Contract.Ensures(Contract.Result<IEnumerable<IDirectory>>() != null);

			throw new NotImplementedException();
		}

 public static List<DirectoryEntry> Search(string rootDistinguishedName, string filter, SearchScope scope, LDAPSupportSettings settings)
 {
     DirectoryEntry de;
     var type = AuthenticationTypes.ReadonlyServer | AuthenticationTypes.Secure;
     if (settings.PortNumber == Constants.SSL_LDAP_PORT)
     {
         type |= AuthenticationTypes.SecureSocketsLayer;
     }
     string password;
     try
     {
         password = new UnicodeEncoding().GetString(InstanceCrypto.Decrypt(settings.PasswordBytes));
     }
     catch (Exception)
     {
         password = string.Empty;
     }
     de = settings.Authentication ? CreateDirectoryEntry(rootDistinguishedName, settings.Login, password, type) :
         CreateDirectoryEntry(rootDistinguishedName);
     if (de != null)
     {
         return Search(de, filter, scope);
     }
     else
     {
         return null;
     }
 }

 public SearchRequest()
 {
     this.directoryAttributes = new StringCollection();
     this.directoryScope = SearchScope.Subtree;
     this.directoryTimeLimit = new TimeSpan(0L);
     this.directoryAttributes = new StringCollection();
 }

        public void Replace(string textToFind, string textToReplace, Document doc, SearchFlags flags, SearchScope scope, int startPosition, int endPosition)
        {
            var ed = App.Editor(doc.GetType()) as ITextEditor;

            if (lastSettings != null &&
                (lastSettings.LastDocument != doc || ed.SelectionStart != lastSettings.LastStartPosition || ed.SelectionEnd != lastSettings.LastEndPosition))
                lastSettings = null;

            if (lastSettings != null)
            {
                ed.ReplaceText(lastSettings.LastStartPosition, lastSettings.LastEndPosition, lastSettings.TextToReplace);
                lastSettings.LastEndPosition = lastSettings.LastStartPosition + lastSettings.TextToReplace.Length;
            }

            var res = Search(textToFind, doc, flags, scope, (d,r) => {
                var editor = (ITextEditor)App.GetService<IEditorService>().GetEditor(d.GetType()).Instance;

                var docServ = App.GetService<IDocumentService>();

                if (docServ.GetActiveDocument() != d)
                    docServ.SetActiveDocument(d);

                editor.SelectText(r.StartPosition, r.EndPosition - r.StartPosition);
                lastSettings.LastStartPosition = r.StartPosition;
                lastSettings.TextToReplace = textToReplace;
                var sci = editor.Control as ScintillaControl;

                if (sci != null)
                    sci.PutArrow(sci.GetLineFromPosition(r.StartPosition));
                return true;
            }, false, lastSettings != null ? lastSettings.LastEndPosition : startPosition, endPosition, null);
            IsFinished(res);
        }

		public static void Run(SearchScope scope) {
			// Allow the menu to close
			Application.DoEvents();
			using(AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:Hornung.ResourceToolkit.FindMissingResourceKeys}")) {
				FindReferencesAndRenameHelper.ShowAsSearchResults(StringParser.Parse("${res:Hornung.ResourceToolkit.ReferencesToMissingKeys}"),
				                                                  ResourceRefactoringService.FindReferencesToMissingKeys(monitor, scope));
			}
		}

		private IDirectorySearcher CreateSearcher(IEntry entry, SearchScope searchScope, string rdnAttribute) {
			var searcher = CreateSearcher(entry, searchScope);
			if(serverConfig.PropertySortingSupport || serverConfig.VirtualListViewSupport) {
				searcher.Sort.PropertyName = rdnAttribute;
				searcher.Sort.Direction = SortDirection.Ascending;
			}
			return searcher;
		}

 public ADSearcher(DirectoryEntry searchRoot, string filter, string[] propertiesToLoad, SearchScope scope)
 {
     this.searcher = new DirectorySearcher(searchRoot, filter, propertiesToLoad, scope);
     this.searcher.CacheResults = false;
     this.searcher.ClientTimeout = defaultTimeSpan;
     this.searcher.ServerPageTimeLimit = defaultTimeSpan;
     this.searcher.PageSize = 0x200;
 }

        /// <summary>
        /// Specifies the scope to use when searching for files.
        /// </summary>
        /// <param name="settings">The sync settings.</param>
        /// <param name="scope">The scope.</param>
        /// <returns>The same <see cref="SyncSettings"/> instance so that multiple calls can be chained.</returns>
        public static SyncSettings SetSearchScope(this SyncSettings settings, SearchScope scope = SearchScope.Current)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.SearchScope = scope;
            return settings;
        }

        /// <summary>
        /// See <see cref="DirectoryInfoUtility.GetFiles(string, SearchScope)"/>.
        /// </summary>
        /// <param name="fileSpec"></param>
        /// <param name="scope"></param>
        /// <returns></returns>
        public static IList<ParsedPath> GetFiles(ParsedPath fileSpec, SearchScope scope)
        {
            IList<FileInfo> fileInfos = DirectoryInfoUtility.GetFiles(fileSpec, scope);

            ParsedPath[] files = new ParsedPath[fileInfos.Count];

            for (int i = 0; i < fileInfos.Count; i++)
                files[i] = new ParsedPath(fileInfos[i].FullName, PathType.File);

            return files;
        }

        /// <summary>
        /// See <see cref="DirectoryInfoUtility.GetDirectories(string, SearchScope)"/>
        /// </summary>
        /// <param name="dirSpec"></param>
        /// <param name="scope"></param>
        /// <returns></returns>
        public static IList<ParsedPath> GetDirectories(ParsedPath dirSpec, SearchScope scope)
        {
            IList<DirectoryInfo> dirInfos = DirectoryInfoUtility.GetDirectories(dirSpec, scope);

            ParsedPath[] dirs = new ParsedPath[dirInfos.Count];

            for (int i = 0; i < dirInfos.Count; i++)
                dirs[i] = new ParsedPath(dirInfos[i].FullName, PathType.Directory);

            return dirs;
        }

 public IEnumerable<IFile> GetFiles(string filter, SearchScope scope)
 {
     var result = new List<IFile>();
     var children = _fileSystem.Files.Where(x => x.Key.FullPath.StartsWith(_path.FullPath + "/", StringComparison.OrdinalIgnoreCase));
     foreach (var child in children.Where(c => c.Value.Exists))
     {
         var relative = child.Key.FullPath.Substring(_path.FullPath.Length + 1);
         if (!relative.Contains("/"))
         {
             result.Add(child.Value);
         }
     }
     return result;
 }

        public ADSearcher(DirectoryEntry searchRoot, string filter, string[] propertiesToLoad, SearchScope scope)
        {
            _searcher = new DirectorySearcher(searchRoot, filter, propertiesToLoad, scope);

            // set all search preferences
            // don't cache the results on the client
            _searcher.CacheResults = false;
            // set the timeout to 2 minutes
            _searcher.ClientTimeout = s_defaultTimeSpan;
            _searcher.ServerPageTimeLimit = s_defaultTimeSpan;
            // Page Size needs to be set so that we 
            // can get all the results even when the number of results 
            // is greater than the server set limit (1000 in Win2000 and 1500 in Win2003)
            _searcher.PageSize = 512;
        }

        public ProxyResponse<SearchResponse> Search(string keywords, SearchScope scope, int pageNumber, int pageSize, string entityType = "", string includeSearchTermHighlights = "false")
        {
            OperationMethod = HttpMethod.Get;
            var queryArgs = new StringBuilder();

            AppendQueryArg(queryArgs, ApiConstants.FilterKeywords, keywords);
            AppendQueryArg(queryArgs, ApiConstants.FilterSearchScope, scope.ToString("G"));
            AppendQueryArg(queryArgs, ApiConstants.FilterSearchTransactionType, entityType);
            AppendQueryArg(queryArgs, ApiConstants.FilterExampleIncludeSearchTermHighlights, includeSearchTermHighlights);

            bool inclPageNumber;
            bool inclPageSize;

            base.GetPaging(queryArgs, pageNumber, pageSize, out inclPageNumber, out inclPageSize);

            var uri = base.GetRequestUri(queryArgs.ToString(), inclDefaultPageNumber: inclPageNumber, inclDefaultPageSize: inclPageSize);
            return base.GetResponse<SearchResponse>(uri);
        }

        /// <summary>
        /// Returns a list of files given a file search pattern.  Will also search sub-directories.
        /// </summary>
        /// <param name="searchPattern">Search pattern.  Can include a full or partial path and standard wildcards for the file name.</param>
        /// <param name="scope">The scope of the search.</param>
        /// <param name="baseDir">Base directory to use for partially qualified paths</param>
        /// <returns>An array of <c>FileInfo</c> objects for files matching the search pattern. </returns>
        public static IList<FileInfo> GetFiles(ParsedPath fileSpec, SearchScope scope)
        {
            ParsedPath rootPath = fileSpec.MakeFullPath();

            if (scope != SearchScope.DirectoryOnly)
            {
                List<FileInfo> files = new List<FileInfo>();

                if (scope == SearchScope.RecurseParentDirectories)
                    RecursiveGetParentFiles(rootPath, ref files);
                else
                    RecursiveGetSubFiles(rootPath, (scope == SearchScope.RecurseSubDirectoriesBreadthFirst), ref files);

                return files.ToArray();
            }
            else
            {
                return NonRecursiveGetFiles(rootPath);
            }
        }

        public List<string> FNSearch(string sql)
        {
            List<string> result = new List<string>();

            SearchSQL searchSql = new SearchSQL(sql);
            SearchScope searchScope = new SearchScope(this._ceConn.objectStore);
            IRepositoryRowSet rowSet = searchScope.FetchRows(searchSql, null, null, null);

            if (rowSet.IsEmpty())
                return null;

            System.Collections.IEnumerator enumerator = rowSet.GetEnumerator();
            while (enumerator.MoveNext())
            {
                IRepositoryRow row = (IRepositoryRow)enumerator.Current;
                Id id = row.Properties.GetProperty("Id").GetIdValue();
                result.Add(id.ToString());
            }

            return result;
        }

 public static void Configure(NameValueCollection sections)
 {
     LdapFilter = sections["LdapFilter"];
     FolderCreatePath= sections["FolderCreatePath"];
     SearchBase = sections["SearchBase"];
     switch (sections["SearchScope"])
     {
         case "Base":
             SearchScope = SearchScope.Base;
             break;
         case "OneLevel":
             SearchScope = SearchScope.OneLevel;
             break;
         case "Subtree":
             SearchScope = SearchScope.Subtree;
             break;
         default:
             throw new ArgumentOutOfRangeException();
     }
     DirectoryEntry= new DirectoryEntry(SearchBase);
     DomainSid= WindowsIdentity.GetCurrent().User.AccountDomainSid;
 }

        /// <summary>
        /// Returns a list of directories given a file search pattern.  Will also search sub-directories and 
        /// parent directories.
        /// </summary>
        /// <param name="dirSpec">Search specification with with optional directory and wildcards</param>
        /// <param name="scope">The scope of the search. <see cref="SearchScope"/></param>
        /// <returns>An array of <c>DirectoryInfo</c> objects for files matching the search pattern. </returns>
        public static IList<DirectoryInfo> GetDirectories(ParsedPath dirSpec, SearchScope scope)
        {
            if (!dirSpec.HasFilename)
                throw new ArgumentException("Path does not have a filename");

            ParsedPath rootPath = dirSpec.MakeFullPath();

            if (scope != SearchScope.DirectoryOnly)
            {
                List<DirectoryInfo> dirs = new List<DirectoryInfo>();

                if (scope == SearchScope.RecurseParentDirectories)
                    RecursiveGetParentDirectories(rootPath, ref dirs);
                else
                    RecursiveGetSubDirectories(rootPath, (scope == SearchScope.RecurseSubDirectoriesBreadthFirst), ref dirs);

                return dirs.ToArray();
            }
            else
            {
                return NonRecursiveGetDirectories(rootPath);
            }
        }

            /// <summary>
            ///     Find all shortcuts in the shortcut lists matching the given class and method.
            /// </summary>
            /// <param name="shortcutClass">The class of the shortcut</param>
            /// <param name="shortcutMethod">The method of the shortcut</param>
            /// <param name="where">A flag to tell where the shortcut should be searched</param>
            /// <returns>A list of matching shortcut data</returns>
            /// <seealso cref="findShortcut"/>
            public List<ShortcutData> findAllShortcuts(string shortcutClass, string shortcutMethod, SearchScope where = SearchScope.All)
            {
                if (mCurrentShortcutsList == mDefaultShortcutsList)
                    return findAllShortcuts(shortcutClass, shortcutMethod, mCurrentShortcutsList);

                switch (where) {
                case SearchScope.AllCurrentFirst:
                    return findAllShortcuts(shortcutClass, shortcutMethod, mCurrentShortcutsList.Concat(mDefaultShortcutsList).ToList());
                case SearchScope.AllDefaultFirst:
                    return findAllShortcuts(shortcutClass, shortcutMethod, mDefaultShortcutsList.Concat(mCurrentShortcutsList).ToList());
                case SearchScope.Current:
                    return findAllShortcuts(shortcutClass, shortcutMethod, mCurrentShortcutsList);
                case SearchScope.Default:
                    return findAllShortcuts(shortcutClass, shortcutMethod, mDefaultShortcutsList);
                default:
                    throw new ArgumentException("Bad value for search scope: " + where);
                }
            }

            /// <summary>
            ///     Find a shortcut in the shortcut lists by modifiers and key.
            /// </summary>
            /// <param name="shortcutModifiers">The modifier of the shortcut</param>
            /// <param name="shortcutKey">The key of the shortcut</param>
            /// <param name="where">A flag to tell where the shortcut should be searched</param>
            /// <returns>The matching shortcut data or <c>null</c> if it is not found</returns>
            /// <seealso cref="findAllShortcuts"/>
            public ShortcutData findShortcut(ShortcutData.Modifiers shortcutModifiers, ShortcutData.Keys shortcutKey, SearchScope where = SearchScope.All)
            {
                if (mCurrentShortcutsList == mDefaultShortcutsList)
                    return findShortcut(shortcutModifiers, shortcutKey, mCurrentShortcutsList);

                switch (where) {
                case SearchScope.AllCurrentFirst:
                    return findShortcut(shortcutModifiers, shortcutKey, mCurrentShortcutsList.Concat(mDefaultShortcutsList).ToList());
                case SearchScope.AllDefaultFirst:
                    return findShortcut(shortcutModifiers, shortcutKey, mDefaultShortcutsList.Concat(mCurrentShortcutsList).ToList());
                case SearchScope.Current:
                    return findShortcut(shortcutModifiers, shortcutKey, mCurrentShortcutsList);
                case SearchScope.Default:
                    return findShortcut(shortcutModifiers, shortcutKey, mDefaultShortcutsList);
                default:
                    throw new ArgumentException("Bad value for search scope: " + where);
                }
            }