public override void Execute(IActionContext context)
{
IResourceList list = Core.ResourceStore.GetAllResources("ColumnScheme");
foreach (IResource res in list)
{
string type = res.GetPropText("ColumnKeyTypes");
if (type == "Email" || type == "Article")
{
int index;
IResourceList descriptors = res.GetLinksOfType("ColumnDescriptor", "ColumnDescriptor");
foreach (IResource descr in descriptors)
{
IStringList props = descr.GetStringListProp("ColumnProps");
index = props.IndexOf("DisplayName");
if (index != -1 && props.Count > 1)
{
Core.ResourceAP.RunUniqueJob(new MyDelegate(RemoveStringListValue), props, index);
MessageBox.Show("Removed prop from ColumnDescriptor " + descr.Id + ", for type=" + type);
}
}
IStringList sortProps = res.GetStringListProp("ColumnSortProps");
index = sortProps.IndexOf("DisplayName");
if (index != -1 && sortProps.Count > 1)
{
Core.ResourceAP.RunUniqueJob(new MyDelegate(RemoveStringListValue), sortProps, index);
MessageBox.Show("Removed prop from ColumnScheme " + res.Id + ", for type=" + type);
}
}
}
}
public static bool IsDefault(IResource folder)
{
Guard.NullArgument(folder, "folder");
if (Folder.IsParentRoot(folder))
{
return(true);
}
IResource mapiStore = GetMAPIStorage(folder);
string storeId = mapiStore.GetStringProp(PROP.StoreID);
IResource mapiInfoStore = Core.ResourceStore.FindUniqueResource(STR.MAPIInfoStore, PROP.EntryID, storeId);
if (mapiInfoStore == null)
{
throw new ApplicationException("Folder.IsDefault -- MAPIStore resource result is null.");
}
IStringList list = mapiInfoStore.GetStringListProp(PROP.DefaultFolderEntryIDs);
if (list == null)
{
throw new ApplicationException("Folder.IsDefault -- List of default store folders is NULL.");
}
return(list.IndexOf(folder.GetStringProp(PROP.EntryID)) != -1);
}
public string ToString(IResource convs)
{
StringBuilder bodyBuilder = StringBuilderPool.Alloc();
try
{
bodyBuilder.Append("<conversation>");
IStringList convsList = convs.GetStringListProp(_propConversationList);
if (!_reverseMode)
{
for (int i = 0; i < convsList.Count; ++i)
{
bodyBuilder.Append(convsList[i]);
}
}
else
{
for (int i = convsList.Count - 1; i >= 0; --i)
{
bodyBuilder.Append(convsList[i]);
}
}
bodyBuilder.Append("</conversation>");
convsList.Dispose();
return(bodyBuilder.ToString());
}
finally
{
StringBuilderPool.Dispose(bodyBuilder);
}
}
private static void SetStringListProp(IResource resource, int propId, string[] values)
{
bool columnPropsOK = false;
IStringList columnProps = resource.GetStringListProp(propId);
if (columnProps.Count == values.Length)
{
columnPropsOK = true;
for (int i = 0; i < columnProps.Count; i++)
{
if (columnProps [i] != values [i])
{
columnPropsOK = false;
break;
}
}
}
if (!columnPropsOK)
{
columnProps.Clear();
for (int i = 0; i < values.Length; i++)
{
columnProps.Add(values [i]);
}
}
}
public override void Execute(IActionContext context)
{
int count = 0;
int resId = 0;
IResourceList list = Core.ResourceStore.GetAllResources("ColumnScheme");
foreach (IResource res in list)
{
string type = res.GetPropText("ColumnKeyTypes");
if (type == "Email" || type == "Article")
{
IResourceList descriptors = res.GetLinksOfType("ColumnDescriptor", "ColumnDescriptor");
foreach (IResource descr in descriptors)
{
IStringList props = descr.GetStringListProp("ColumnProps");
int index = props.IndexOf("DisplayName");
if (index != -1 && props.Count > 1)
{
count++;
if (resId == 0)
{
resId = descr.Id;
}
}
}
}
}
MessageBox.Show("Count of such columns is " + count + " with first id = " + resId);
}
protected override void Execute()
{
if (_resource != null && _resource.IsDeleted)
{
return;
}
if (_deletedItemsId == null && _entryId == null)
{
return;
}
if (_resource == null && _deletedItemsId != null)
{
_resource = Core.ResourceStore.FindUniqueResource(STR.MAPIInfoStore,
PROP.DeletedItemsEntryID, _deletedItemsId);
}
if (_resource == null)
{
_resource = Core.ResourceStore.BeginNewResource(STR.MAPIInfoStore);
}
else
{
_resource.BeginUpdate();
}
IStringList propList = _resource.GetStringListProp(PROP.DefaultFolderEntryIDs);
propList.Clear();
foreach (string entryId in _defaultFolderEntryIDs)
{
propList.Add(entryId);
}
_resource.SetProp(PROP.EntryID, _entryId);
_resource.SetProp(PROP.DeletedItemsEntryID, _deletedItemsId);
_resource.SetProp(PROP.JunkEmailEntryID, _junkEmailId);
_resource.SetProp(PROP.PR_STORE_SUPPORT_MASK, _supportMask);
_resource.SetProp(PROP.StoreSupported, _supported);
if (!_supported)
{
_resource.SetProp(PROP.IgnoredFolder, 1);
_name += " (Not supported)";
}
else if ((_supportMask & STORE_SUPPORT_MASK.STORE_PUBLIC_FOLDERS) != 0)
{
_resource.SetProp(PROP.IgnoredFolder, 1);
}
_resource.SetProp(Core.Props.Name, _name);
_resource.SetProp(PROP.StoreTypeChecked, _storeTypeChecked);
_resource.EndUpdate();
}
///////////////////////////////////////////////////////////////////////
public void Add(
IStringList list,
int startIndex
)
{
#if CACHE_STRINGLIST_TOSTRING
InvalidateCachedString();
#endif
for (int index = startIndex; index < list.Count; index++)
{
base.Add(list.GetItem(index));
}
}
public void TestStringListProps()
{
ResourceSerializer serializer = new ResourceSerializer();
IResource origin = _storage.NewResource("Email");
origin.SetProp(_propSize, 100);
origin.SetProp(_propReceived, DateTime.Now);
IStringList strLst = origin.GetStringListProp(_propValueList);
using ( strLst )
{
strLst.Add("One");
strLst.Add("Two");
strLst.Add("Three");
}
origin.SetProp(_propUnread, true);
origin.SetProp(_propSimilarity, 1.0);
ResourceNode resNode = serializer.AddResource(origin);
foreach (IResourceProperty prop in origin.Properties)
{
resNode.AddProperty(prop);
}
serializer.GenerateXML("SerializationResult.xml");
origin.Delete();
StreamReader sr = new StreamReader("SerializationResult.xml", Encoding.Default);
string str = Utils.StreamReaderReadToEnd(sr);
Console.WriteLine(str);
sr.Close();
ResourceDeserializer deserializer = new ResourceDeserializer("SerializationResult.xml");
ArrayList list = deserializer.GetSelectedResources();
Assert.AreEqual(1, list.Count, "List must contain only one resource. Current count is [" + list.Count + "]");
ResourceUnpack ru = (ResourceUnpack)list[0];
origin = ru.Resource;
Assert.IsTrue(origin.HasProp(_propValueList),
"Resource must contain StringList property");
IStringList stringsList = origin.GetStringListProp(_propValueList);
Assert.AreEqual(3, stringsList.Count, "StringList must contain three elements. Current count is [" + stringsList.Count + "]");
Assert.AreEqual("One", stringsList [0], "StringList[ 0 ] must be equal to [One]. Current value is [" + stringsList[0] + "]");
Assert.AreEqual("Two", stringsList [1], "StringList[ 1 ] must be equal to [Two]. Current value is [" + stringsList[1] + "]");
Assert.AreEqual("Three", stringsList [2], "StringList[ 2 ] must be equal to [Three]. Current value is [" + stringsList[2] + "]");
}
private static ColumnDescriptor LoadColumnDescriptor(IResource resource)
{
DisplayColumnProps props = (Core.DisplayColumnManager as DisplayColumnManager).Props;
IStringList columnPropList = resource.GetStringListProp(props.ColumnProps);
string[] columnProps = new string [columnPropList.Count];
for (int i = 0; i < columnPropList.Count; i++)
{
columnProps [i] = columnPropList [i];
}
int width = resource.GetIntProp(props.ColumnWidth);
ColumnDescriptorFlags flags = (ColumnDescriptorFlags)resource.GetIntProp(props.ColumnFlags);
return(new ColumnDescriptor(columnProps, width, flags));
}
public string GetPreviewText(IResource res, int lines)
{
StringBuilder builder = StringBuilderPool.Alloc();
try
{
builder.Append("<conversation>");
IStringList convsList = res.GetStringListProp(_manager._propConversationList);
if (!_manager._reverseMode)
{
for (int i = 0; i < convsList.Count && lines-- > 0; ++i)
{
builder.Append(convsList[i]);
}
}
else
{
for (int i = convsList.Count - 1; i >= 0 && lines-- > 0; --i)
{
builder.Append(convsList[i]);
}
}
convsList.Dispose();
builder.Append("</conversation>");
XmlTextReader reader = new XmlTextReader(new StringReader(builder.ToString()));
builder.Length = 0;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.MoveToAttribute("body"))
{
builder.AppendFormat("{0}\r\n", reader.Value);
}
reader.MoveToElement();
}
}
return(builder.ToString());
}
finally
{
StringBuilderPool.Dispose(builder);
}
}
///////////////////////////////////////////////////////////////////////
public void Add(
IStringList list,
int startIndex
)
{
for (int index = startIndex; index < list.Count; index++)
{
IPair <string> item = list.GetPair(index);
if (item != null)
{
Add(item);
}
else
{
Add((IPair <string>)null);
}
}
}
private static SortSettings LoadSortSettings(IResource res, DisplayColumnProps props)
{
IStringList sortPropList = res.GetStringListProp(props.ColumnSortProps);
IntArrayList sortProps = IntArrayListPool.Alloc();
try
{
for (int i = 0; i < sortPropList.Count; i++)
{
string sortPropName = sortPropList [i];
if (sortPropName == "DisplayName")
{
sortProps.Add(ResourceProps.DisplayName);
}
else if (sortPropName == "Type")
{
sortProps.Add(ResourceProps.Type);
}
else if (sortPropName.StartsWith("-"))
{
sortPropName = sortPropName.Substring(1);
if (Core.ResourceStore.PropTypes.Exist(sortPropName))
{
sortProps.Add(-Core.ResourceStore.PropTypes [sortPropName].Id);
}
}
else
{
if (Core.ResourceStore.PropTypes.Exist(sortPropName))
{
sortProps.Add(Core.ResourceStore.PropTypes [sortPropName].Id);
}
}
}
bool sortAsc = res.HasProp(props.ColumnSortAsc);
return(new SortSettings(sortProps.ToArray(), sortAsc));
}
finally
{
IntArrayListPool.Dispose(sortProps);
}
}
///////////////////////////////////////////////////////////////////////
public ReturnCode Add(
IStringList arguments,
ref Result error
)
{
if (arguments == null)
{
error = "invalid argument list";
return(ReturnCode.Error);
}
if (items == null)
{
error = "items not available";
return(ReturnCode.Error);
}
items.Add(GetNextKey(), arguments);
return(ReturnCode.Ok);
}
private static BookmarkChange[] ParseChangesLog(string profileName)
{
IBookmarkService service =
(IBookmarkService)Core.PluginLoader.GetPluginService(typeof(IBookmarkService));
IResource profileRoot = service.GetProfileRoot(
BookmarkService.NormalizeProfileName("Mozilla/" + profileName));
if (profileRoot != null)
{
Trace.WriteLine("ParseChangesLog( " + profileName + " ) : profileRoot != null");
MozillaBookmarkProfile profile =
service.GetOwnerProfile(profileRoot) as MozillaBookmarkProfile;
if (profile != null)
{
Trace.WriteLine("ParseChangesLog( " + profileName + " ) : profile != null");
profile.IsActive = true;
IStringList log = profileRoot.GetStringListProp(_propChangesLog);
if (log.Count > 0)
{
Trace.WriteLine("ParseChangesLog( " + profileName + " ) : log.Count > 0");
BookmarkChange[] result = new BookmarkChange[log.Count];
for (int i = 0; i < result.Length; ++i)
{
string[] changeFields = log[i].Split('\x01');
result[i].type = Int32.Parse(changeFields[0]);
result[i].id = Int32.Parse(changeFields[1]);
result[i].rdfid = changeFields[2];
result[i].oldparent = changeFields[3];
result[i].oldparent_id = Int32.Parse(changeFields[4]);
result[i].parent = changeFields[5];
result[i].parent_id = Int32.Parse(changeFields[6]);
result[i].name = changeFields[7];
result[i].url = changeFields[8];
}
profileRoot.DeleteProp(_propChangesLog);
return(result);
}
}
}
return(null);
}
private void UpdateProperty(int propId, IResource source, IResource target)
{
if (source.HasProp(propId))
{
if (Core.ResourceStore.PropTypes[propId].DataType != PropDataType.StringList)
{
target.SetProp(propId, source.GetProp(propId));
}
else
{
IStringList strList = target.GetStringListProp(propId);
foreach (string str in source.GetStringListProp(propId))
{
if (strList.IndexOf(str) == -1)
{
strList.Add(str);
}
}
}
}
}
///////////////////////////////////////////////////////////////////////
#if BREAKPOINTS
public ReturnCode GetBreakpointList(
Interpreter interpreter,
string pattern,
bool noCase,
ref IStringList list,
ref Result error
)
{
CheckDisposed();
BreakpointDictionary breakpoints = Breakpoints;
if (breakpoints != null)
{
list = breakpoints.ToList(pattern, noCase);
return(ReturnCode.Ok);
}
else
{
error = "breakpoints not available";
}
return(ReturnCode.Error);
}
public void TestMixedProps()
{
IResource origin = _storage.NewResource("Email");
IResource person = _storage.NewResource("Person");
origin.AddLink(_propAuthor, person);
origin.SetProp(_propSize, 100);
DateTime now = DateTime.Now;
origin.SetProp(_propReceived, now);
IStringList strLst = origin.GetStringListProp(_propValueList);
using ( strLst )
{
strLst.Add("One");
strLst.Add("Two");
strLst.Add("Three");
}
origin.SetProp(_propUnread, true);
origin.SetProp(_propSimilarity, 1.0);
Stream stream = ResourceBinarySerialization.Serialize(origin);
origin.Delete();
origin = ResourceBinarySerialization.Deserialize(stream);
Assert.IsTrue(person.HasLink(_propAuthor, origin), "Person has no link to deserialized origin");
Assert.AreEqual(100, origin.GetIntProp(_propSize), "Deserialized origin has invalid size");
Assert.AreEqual(now, origin.GetDateProp(_propReceived), "Deserialized origin has invalid received date");
strLst = origin.GetStringListProp(_propValueList);
using ( strLst )
{
Assert.IsTrue(strLst.Count == 3 && strLst[0] == "One" && strLst[1] == "Two" && strLst[2] == "Three",
"Deserialized origin has invalid value list");
}
Assert.IsTrue(origin.HasProp(_propUnread), "Deserialized origin is read");
Assert.IsTrue(origin.GetDoubleProp(_propSimilarity) == 1.0, "Deserialized origin has invalid similarity");
}
private void SetProperty(XmlNode propertyNode)
{
XmlAttribute typeAttribute = (XmlAttribute)propertyNode.Attributes.GetNamedItem("Type");
string strType = typeAttribute.InnerText;
object value = null;
switch (strType)
{
case "Bool":
value = Convert.ToBoolean(propertyNode.InnerText);
break;
case "Date":
Tracer._Trace("Try to parse " + propertyNode.InnerText + " for " + propertyNode.Name);
long ticks = Convert.ToInt64(propertyNode.InnerText);
DateTime dateTime = new DateTime(ticks);
if (dateTime != DateTime.MinValue)
{
value = dateTime;
}
break;
case "Double":
value = Convert.ToDouble(propertyNode.InnerText);
break;
case "Int":
value = Convert.ToInt32(propertyNode.InnerText);
break;
case "LongString":
value = propertyNode.InnerText;
break;
case "String":
value = propertyNode.InnerText;
break;
case "StringList":
// Elements of the string list are stored as separate
// nodes of name "StringField"
ArrayList fields = new ArrayList();
foreach (XmlNode node in propertyNode.ChildNodes)
{
if (node.Name == "StringField")
{
fields.Add(node.InnerText);
}
}
IStringList val = _resource.GetStringListProp(propertyNode.Name);
foreach (string str in fields)
{
val.Add(str);
}
value = val;
break;
default:
throw new ArgumentOutOfRangeException("ResourceDeserialization -- Can not process" +
" resource type [" + strType + "]");
}
if (value != null)
{
if (Core.ResourceStore.PropTypes.Exist(propertyNode.Name))
{
// String list value is set impliit through initialization of
// the property content elements.
if (strType != "StringList")
{
_resource.SetProp(propertyNode.Name, value);
}
}
}
}
public Keyword(string keyexp, IStringList[] lists)
{
Lists = lists;
m_Keywords = new Regex(keyexp, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase);
}
private static Result FromList(
IStringList value
)
{
return(new Result((object)value));
}
public static IResource Deserialize(Stream stream, BeforeDeserializationDelegate beforeCheck)
{
if (stream.CanSeek)
{
stream.Position = 0;
}
BinaryReader reader = new BinaryReader(stream);
using ( reader )
{
string resType = reader.ReadString();
IResource result = Core.ResourceStore.BeginNewResource(resType);
try
{
int propCount = reader.ReadInt32();
for (int i = 0; i < propCount; ++i)
{
PropDataType propType = (PropDataType)reader.ReadInt32();
int propId = reader.ReadInt32();
switch (propType)
{
case PropDataType.Link:
{
int count = reader.ReadInt32();
for (int j = 0; j < count; ++j)
{
LinkResource(reader, result, propId, beforeCheck);
}
break;
}
case PropDataType.String:
case PropDataType.LongString:
{
result.SetProp(propId, reader.ReadString());
break;
}
case PropDataType.StringList:
{
int count = reader.ReadInt32();
IStringList strLst = result.GetStringListProp(propId);
using ( strLst )
{
for (int j = 0; j < count; ++j)
{
strLst.Add(reader.ReadString());
}
}
break;
}
case PropDataType.Int:
{
result.SetProp(propId, reader.ReadInt32());
break;
}
case PropDataType.Date:
{
result.SetProp(propId, new DateTime(reader.ReadInt64()));
break;
}
case PropDataType.Bool:
{
result.SetProp(propId, true);
break;
}
case PropDataType.Double:
{
result.SetProp(propId, reader.ReadDouble());
break;
}
case PropDataType.Blob:
{
int length = reader.ReadInt32();
byte[] buffer = new byte[length];
reader.Read(buffer, 0, length);
result.SetProp(propId, new JetMemoryStream(buffer, true));
break;
}
}
}
}
finally
{
result.EndUpdate();
}
return(result);
}
}
/**
* User should manually close returned stream
*/
public static Stream Serialize(IResource resource)
{
JetMemoryStream result = new JetMemoryStream();
BinaryWriter writer = new BinaryWriter(result);
writer.Write(resource.Type);
writer.Write(resource.Properties.Count);
foreach (IResourceProperty prop in resource.Properties)
{
writer.Write((int)prop.DataType);
int propId = prop.PropId;
writer.Write(propId);
switch (prop.DataType)
{
case PropDataType.Link:
{
IResourceList links;
if (Core.ResourceStore.PropTypes[propId].HasFlag(PropTypeFlags.DirectedLink))
{
links = (propId < 0) ? resource.GetLinksTo(null, -propId) : resource.GetLinksFrom(null, propId);
}
else
{
links = resource.GetLinksOfType(null, propId);
}
writer.Write(links.Count);
foreach (IResource linked in links)
{
writer.Write(linked.Id);
}
break;
}
case PropDataType.String:
case PropDataType.LongString:
{
writer.Write(resource.GetPropText(propId));
break;
}
case PropDataType.StringList:
{
IStringList strList = resource.GetStringListProp(propId);
int count = strList.Count;
writer.Write(count);
for (int i = 0; i < count; ++i)
{
writer.Write(strList[i]);
}
break;
}
case PropDataType.Int:
{
writer.Write(resource.GetIntProp(propId));
break;
}
case PropDataType.Date:
{
writer.Write(resource.GetDateProp(propId).Ticks);
break;
}
case PropDataType.Bool:
{
/**
* if a resource has bool prop, then it's equal to 'true'
* there is no need always to write 'true' to stream :-)
*/
break;
}
case PropDataType.Double:
{
writer.Write(resource.GetDoubleProp(propId));
break;
}
case PropDataType.Blob:
{
Stream stream = resource.GetBlobProp(propId);
writer.Write((int)stream.Length);
FileResourceManager.CopyStream(stream, result);
break;
}
default:
{
throw new Exception("Serialized resource has properties of unknown type");
}
}
}
return(result);
}
private static void RemoveStringListValue(IStringList props, int index)
{
props.RemoveAt(index);
}
public static bool Find(IStringList List, Hashtable DelimTable, string String, SearchOptions Options, Regex Expression, ref Point Position, out int Len)
{
Len = String.Length;
if ((String != null) && (String != string.Empty))
{
bool flag1 = ((Options & SearchOptions.CaseSensitive) == SearchOptions.None) && (Expression == null);
if (flag1)
{
String = String.ToUpper();
}
string text1 = null;
int num1 = 0;
int num2 = 0;
if ((Options & SearchOptions.BackwardSearch) == SearchOptions.None)
{
Label_031C:
if (Position.Y < List.Count)
{
text1 = List[Position.Y];
if ((Position.X < text1.Length) || (((text1 == string.Empty) && (Position.X == 0)) && (Expression != null)))
{
if (flag1)
{
text1 = text1.ToUpper();
}
Position.X = Math.Min(Position.X, (int)(text1.Length - 1));
if (Expression != null)
{
Match match2 = (text1 == string.Empty) ? Expression.Match(text1) : Expression.Match(text1, Position.X);
if (match2.Success)
{
Len = match2.Length;
Position.X = match2.Index;
}
else
{
Position.X = -1;
}
}
else if (text1 != string.Empty)
{
Position.X = text1.IndexOf(String, Position.X);
}
else
{
Position.X = -1;
}
if (((Position.X >= 0) && ((Options & SearchOptions.WholeWordsOnly) != SearchOptions.None)) && !SyntaxStrings.IsWholeWord(DelimTable, text1, Position.X, Len, ref num1, ref num2))
{
Position.X = (Position.X == num2) ? (Position.X + 1) : num2;
goto Label_031C;
}
if (Position.X >= 0)
{
return(true);
}
}
Position.Y++;
Position.X = 0;
goto Label_031C;
}
}
else
{
Position.Y = Math.Min(Position.Y, (int)(List.Count - 1));
while (Position.Y >= 0)
{
text1 = List[Position.Y];
if ((Position.X > 0) || (((text1 == string.Empty) && (Position.X == 0)) && (Expression != null)))
{
if (flag1)
{
text1 = text1.ToUpper();
}
if (Expression != null)
{
Match match1 = (text1 == string.Empty) ? Expression.Match(text1) : Expression.Match(text1, Math.Min(Position.X, (int)(text1.Length - 1)));
if (match1.Success)
{
Len = match1.Length;
Position.X = match1.Index;
}
else
{
Position.X = -1;
}
}
else if (text1 != string.Empty)
{
Position.X = text1.LastIndexOf(String, Math.Min((int)(Position.X - 1), (int)(text1.Length - 1)));
}
else
{
Position.X = -1;
}
if (((Position.X >= 0) && ((Options & SearchOptions.WholeWordsOnly) != SearchOptions.None)) && !SyntaxStrings.IsWholeWord(DelimTable, text1, Position.X, Len, ref num1, ref num2))
{
Position.X = num1 - 1;
continue;
}
if (Position.X >= 0)
{
return(true);
}
}
Position.Y--;
if (Position.Y >= 0)
{
Position.X = List[Position.Y].Length;
}
}
}
}
return(false);
}
