public void InitEx(PwGroup pgDataSource, bool bPrintMode)
        {
            Debug.Assert(pgDataSource != null); if(pgDataSource == null) throw new ArgumentNullException("pgDataSource");

            m_pgDataSource = pgDataSource;
            m_bPrintMode = bPrintMode;
        }

		private static void ImportRecord(Node<BaseRecord> currentNode, PwGroup groupAddTo, PwDatabase pwStorage)
		{
			BaseRecord record = currentNode.AssociatedObject;

			if (record.GetType() == typeof(FolderRecord))
			{
				FolderRecord folderRecord = (FolderRecord)record;
				var folder = CreateFolder(groupAddTo, folderRecord);

				foreach (var node in currentNode.Nodes)
				{
					ImportRecord(node, folder, pwStorage);
				}
			}
			else if (record.GetType() == typeof(WebFormRecord))
			{
				WebFormRecord webForm = (WebFormRecord)record;
				CreateWebForm(groupAddTo, pwStorage, webForm);
			}
			else if (record.GetType() == typeof(BaseRecord))
			{
				//Trace.WriteLine(String.Format("Error. Can't import unknown record type: {0}", record.RawJson));
			}
			else if (record.GetType() == typeof(UnknownRecord))
			{
				//CreateUnknown(groupAddTo, pwStorage, record as UnknownRecord);
			}
		}

        public void InitEx(PwGroup pgEntrySource, ImageList ilClientIcons,
			string strDefaultRef)
        {
            m_pgEntrySource = pgEntrySource;
            m_ilIcons = ilClientIcons;
            m_strDefaultRef = (strDefaultRef ?? string.Empty);
        }

        public static string CreateSummaryList(PwGroup pgItems, bool bStartWithNewPar)
        {
            List<PwEntry> l = pgItems.GetEntries(true).CloneShallowToList();
            string str = CreateSummaryList(pgItems, l.ToArray());

            if((str.Length == 0) || !bStartWithNewPar) return str;
            return (MessageService.NewParagraph + str);
        }

		public void InitEx(PwGroup pgDataSource, bool bPrintMode, int nDefaultSortColumn)
		{
			Debug.Assert(pgDataSource != null); if(pgDataSource == null) throw new ArgumentNullException("pgDataSource");

			m_pgDataSource = pgDataSource;
			m_bPrintMode = bPrintMode;
			m_nDefaultSortColumn = nDefaultSortColumn;
		}

			public GxiContext ModifyWith(PwGroup pg)
			{
				GxiContext c = (GxiContext)MemberwiseClone();
				Debug.Assert(object.ReferenceEquals(c.m_dStringKeyRepl, m_dStringKeyRepl));

				c.m_pg = pg;
				return c;
			}

 public MoveElement(IStructureItem elementToMove, PwGroup targetGroup, Context ctx, IKp2aApp app, OnFinish finish)
     : base(finish)
 {
     _elementToMove = elementToMove;
     _targetGroup = targetGroup;
     _ctx = ctx;
     _app = app;
 }

        public void InitEx(PwGroup pg, bool bCreatingNew, ImageList ilClientIcons,
			PwDatabase pwDatabase)
        {
            m_pwGroup = pg;
            m_bCreatingNew = bCreatingNew;
            m_ilClientIcons = ilClientIcons;
            m_pwDatabase = pwDatabase;
        }

		// public void Save(string strFile, PwGroup pgDataSource, KdbxFormat format,
		//	IStatusLogger slLogger)
		// {
		//	bool bMadeUnhidden = UrlUtil.UnhideFile(strFile);
		//
		//	IOConnectionInfo ioc = IOConnectionInfo.FromPath(strFile);
		//	this.Save(IOConnection.OpenWrite(ioc), pgDataSource, format, slLogger);
		//
		//	if(bMadeUnhidden) UrlUtil.HideFile(strFile, true); // Hide again
		// }

		/// <summary>
		/// Save the contents of the current <c>PwDatabase</c> to a KDBX file.
		/// </summary>
		/// <param name="sSaveTo">Stream to write the KDBX file into.</param>
		/// <param name="pgDataSource">Group containing all groups and
		/// entries to write. If <c>null</c>, the complete database will
		/// be written.</param>
		/// <param name="format">Format of the file to create.</param>
		/// <param name="slLogger">Logger that recieves status information.</param>
		public void Save(Stream sSaveTo, PwGroup pgDataSource, KdbxFormat format,
			IStatusLogger slLogger)
		{
			Debug.Assert(sSaveTo != null);
			if(sSaveTo == null) throw new ArgumentNullException("sSaveTo");

			m_format = format;
			m_slLogger = slLogger;

			HashingStreamEx hashedStream = new HashingStreamEx(sSaveTo, true, null);

			UTF8Encoding encNoBom = StrUtil.Utf8;
			CryptoRandom cr = CryptoRandom.Instance;

			try
			{
				m_pbMasterSeed = cr.GetRandomBytes(32);
				m_pbTransformSeed = cr.GetRandomBytes(32);
				m_pbEncryptionIV = cr.GetRandomBytes(16);

				m_pbProtectedStreamKey = cr.GetRandomBytes(32);
				m_craInnerRandomStream = CrsAlgorithm.Salsa20;
				m_randomStream = new CryptoRandomStream(m_craInnerRandomStream,
					m_pbProtectedStreamKey);

				m_pbStreamStartBytes = cr.GetRandomBytes(32);

				Stream writerStream;
				if(m_format == KdbxFormat.Default)
				{
					WriteHeader(hashedStream); // Also flushes the stream

					Stream sEncrypted = AttachStreamEncryptor(hashedStream);
					if((sEncrypted == null) || (sEncrypted == hashedStream))
						throw new SecurityException(KLRes.CryptoStreamFailed);

					sEncrypted.Write(m_pbStreamStartBytes, 0, m_pbStreamStartBytes.Length);

					Stream sHashed = new HashedBlockStream(sEncrypted, true);

					if(m_pwDatabase.Compression == PwCompressionAlgorithm.GZip)
						writerStream = new GZipStream(sHashed, CompressionMode.Compress);
					else
						writerStream = sHashed;
				}
				else if(m_format == KdbxFormat.PlainXml)
					writerStream = hashedStream;
				else { Debug.Assert(false); throw new FormatException("KdbFormat"); }

				m_xmlWriter = new XmlTextWriter(writerStream, encNoBom);
				WriteDocument(pgDataSource);

				m_xmlWriter.Flush();
				m_xmlWriter.Close();
				writerStream.Close();
			}
			finally { CommonCleanUpWrite(sSaveTo, hashedStream); }
		}

        public static void Launch(Activity act, PwGroup parentGroup)
        {
            Intent i = new Intent(act, typeof(GroupEditActivity));

            PwGroup parent = parentGroup;
            i.PutExtra(KeyParent, parent.Uuid.ToHexString());

            act.StartActivityForResult(i, 0);
        }

 public static string GetGroupPath(PwGroup group)
 {
     string path = GetGroupPathRec(group);
     if (path.Length > 0) {
         return path;
     } else {
         return "(Root)";
     }
 }

 private static string GetGroupPathRec(PwGroup group)
 {
     if (group.ParentGroup != null) {
         string parent = GetGroupPathRec(group.ParentGroup);
         return parent + (parent.Length > 0 ? "/" : "") + group.Name;
     } else {
         // Empty, because we don't need the name of DB in path, which is the root.
         return "";
     }
 }

        private void AddProduct(PwDatabase database, PwGroup group, Product product)
        {
            var productGroup = group.FindCreateGroup(product.Name, true);

            foreach (var key in product.Keys)
            {
                if(!GroupContainsKeyAsPassword(productGroup,key))
                    AddKey(database, productGroup, key);
            }
        }

        private void AddKey(PwDatabase database, PwGroup group, Key key)
        {
            var entry = new PwEntry(true, true);

            group.AddEntry(entry, true);

            entry.Strings.Set(PwDefs.TitleField, new ProtectedString(database.MemoryProtection.ProtectTitle, key.Type));
            entry.Strings.Set(PwDefs.PasswordField, new ProtectedString(database.MemoryProtection.ProtectPassword, key.Value));
            entry.Strings.Set(PwDefs.NotesField, new ProtectedString(database.MemoryProtection.ProtectNotes, key.Description));
        }

        protected AddEntry(Context ctx, IKp2aApp app, PwEntry entry, PwGroup parentGroup, OnFinish finish)
            : base(finish)
        {
            _ctx = ctx;
            _parentGroup = parentGroup;
            _app = app;
            _entry = entry;

            _onFinishToRun = new AfterAdd(app.GetDb(), entry, OnFinishToRun);
        }

        public Search(PwGroup rootGroup)
        {
            this.rootGroup = rootGroup;

            this.SearchInTitle = Settings.Default.SearchInTitle;
            this.SearchInUrl = Settings.Default.SearchInUrl;
            this.SearchInUserName = Settings.Default.SearchInUserName;
            this.SearchInNotes = Settings.Default.SearchInNotes;
            this.SearchInPassword = Settings.Default.SearchInPassword;
            this.searchInOther = Settings.Default.SearchInOther;
        }

		private void ConstructEx(PwGroup pgDataSource, PwDatabase pwContextInfo,
			bool? bExportDeleted)
		{
			if(pgDataSource == null) throw new ArgumentNullException("pgDataSource");
			// pwContextInfo may be null

			m_pg = pgDataSource;
			m_pd = pwContextInfo;

			if(bExportDeleted.HasValue) m_bExpDel = bExportDeleted.Value;
		}

 private void add_sub_groups(PwGroup group, int level, string cur_item_uuid)
 {
     PwObjectList<PwGroup> groups = group.GetGroups(false);
     foreach (PwGroup sub_group in groups)
     {
         StartGroupDropdown item = new StartGroupDropdown(sub_group.Uuid.ToHexString(), sub_group.Name, level + 1);
         if (sub_group.Uuid.ToHexString() == cur_item_uuid)
             drop_cur_item = item;
         drop_items.Add(item);
         add_sub_groups(sub_group, level + 1, cur_item_uuid);
     }
 }

        public override void Run()
        {
            StatusLogger.UpdateMessage(UiStringKey.AddingGroup);
            // Generate new group
            Group = new PwGroup(true, true, _name, (PwIcon)_iconId);
            Parent.AddGroup(Group, true);

            // Commit to disk
            SaveDb save = new SaveDb(_ctx, _app, OnFinishToRun, DontSave);
            save.SetStatusLogger(StatusLogger);
            save.Run();
        }

        private AddGroup(Context ctx, IKp2aApp app, String name, int iconid, PwGroup parent, OnFinish finish, bool dontSave)
            : base(finish)
        {
            _ctx = ctx;
            _name = name;
            _iconId = iconid;
            Parent = parent;
            DontSave = dontSave;
            _app = app;

            _onFinishToRun = new AfterAdd(this, OnFinishToRun);
        }