search/Tiles/Utils.cs

   1 using System;
   2 using System.Globalization;
   3 using Mono.Unix;
   4
   5 namespace Search.Tiles {
   6
   7         public struct TileGroupInfo {
   8                 public TileGroup Group;
   9                 public string Name;
  10                 public int Rows;
  11
  12                 public TileGroupInfo (TileGroup group, string name, int rows)
  13                 {
  14                         Group = group;
  15                         Name = name;
  16                         Rows = rows;
  17                 }
  18         };
  19
  20         public static class Utils {
  21
  22                 public static TileGroupInfo[] GroupInfo = new TileGroupInfo[] {
  23                         new TileGroupInfo (TileGroup.Application,
  24                                            Catalog.GetString ("Applications"), 1),
  25                         new TileGroupInfo (TileGroup.Contact,
  26                                            Catalog.GetString ("Contacts"), 2),
  27                         new TileGroupInfo (TileGroup.Calendar,
  28                                            Catalog.GetString ("Calendar Events"), 2),
  29                         new TileGroupInfo (TileGroup.Folder,
  30                                            Catalog.GetString ("Folders"), 2),
  31                         new TileGroupInfo (TileGroup.Image,
  32                                            Catalog.GetString ("Images"), 2),
  33                         new TileGroupInfo (TileGroup.Audio,
  34                                            Catalog.GetString ("Audio"), 2),
  35                         new TileGroupInfo (TileGroup.Video,
  36                                            Catalog.GetString ("Video"), 2),
  37                         new TileGroupInfo (TileGroup.Documents,
  38                                            Catalog.GetString ("Documents"), 2),
  39                         new TileGroupInfo (TileGroup.Conversations,
  40                                            Catalog.GetString ("Conversations"), 5),
  41                         new TileGroupInfo (TileGroup.Website,
  42                                            Catalog.GetString ("Websites"), 2),
  43                         new TileGroupInfo (TileGroup.Feed,
  44                                            Catalog.GetString ("News Feeds"), 2),
  45                         new TileGroupInfo (TileGroup.Archive,
  46                                            Catalog.GetString ("Archives"), 2),
  47                 };
  48
  49                 public static ScopeType TileGroupToScopeType (TileGroup group)
  50                 {
  51                         switch (group) {
  52
  53                         case TileGroup.Application:
  54                                 return ScopeType.Applications;
  55
  56                         case TileGroup.Calendar:
  57                                 return ScopeType.Calendar;
  58
  59                         case TileGroup.Contact:
  60                                 return ScopeType.Contacts;
  61
  62                         // This TileGroup exists but does not seem to be used
  63                         // case TileGroup.Folder:
  64                         case TileGroup.Documents:
  65                                 return ScopeType.Documents;
  66
  67                         case TileGroup.Conversations:
  68                                 return ScopeType.Conversations;
  69
  70                         case TileGroup.Image:
  71                                 return ScopeType.Images;
  72
  73                         case TileGroup.Audio:
  74                                 return ScopeType.Media;
  75
  76                         case TileGroup.Video:
  77                                 return ScopeType.Media;
  78
  79                         case TileGroup.Folder:
  80                                 return ScopeType.Folders;
  81
  82                         case TileGroup.Website:
  83                                 return ScopeType.Websites;
  84
  85                         case TileGroup.Feed:
  86                                 return ScopeType.Feeds;
  87
  88                         case TileGroup.Archive:
  89                                 return ScopeType.Archives;
  90
  91                         }
  92
  93                         Console.WriteLine ("Error: Could not find ScopeType for Group: {0}",group);
  94                         return ScopeType.Nothing;
  95                 }
  96
  97                 public static string GetFirstPropertyOfParent (Beagle.Hit hit, string prop)
  98                 {
  99                         if (hit.ParentUri == null)
 100                                 return hit.GetFirstProperty (prop);
 101                         else
 102                                 return hit.GetFirstProperty ("parent:" + prop);
 103                 }
 104
 105                 public static DateTime ParseTimestamp (string timestamp)
 106                 {
 107                         DateTime dt;
 108                         dt = new DateTime (Int32.Parse (timestamp.Substring (0, 4)),
 109                                            Int32.Parse (timestamp.Substring (4, 2)),
 110                                            Int32.Parse (timestamp.Substring (6, 2)),
 111                                            Int32.Parse (timestamp.Substring (8, 2)),
 112                                            Int32.Parse (timestamp.Substring (10, 2)),
 113                                            Int32.Parse (timestamp.Substring (12, 2)));
 114                         return dt;
 115                 }
 116
 117                 private static DateTimeFormatInfo DateTimeFormat = CultureInfo.CurrentCulture.DateTimeFormat;
 118                 private static string ShortMonthDayPattern = DateTimeFormat.MonthDayPattern.Replace ("MMMM", "MMM");
 119                 private static string ShortYearMonthPattern = DateTimeFormat.YearMonthPattern.Replace ("MMMM", "MMM");
 120                 private static string MonthDayPattern = DateTimeFormat.MonthDayPattern;
 121                 private static string LongDatePattern = DateTimeFormat.LongDatePattern.Replace ("dddd, ", "").Replace ("dddd ", "").Replace (" dddd", "");
 122
 123                 private static string NiceDatePattern (DateTime dt, string month_day_pattern, string year_month_pattern)
 124                 {
 125                         if (dt.Year <= 1970)
 126                                 return "-";
 127
 128                         dt = dt.ToLocalTime ().Date;
 129                         DateTime today = DateTime.Today;
 130                         TimeSpan one_day = new TimeSpan (TimeSpan.TicksPerDay);
 131
 132                         if (dt == today - one_day)
 133                                 return Catalog.GetString ("Yesterday");
 134                         else if (dt == today)
 135                                 return Catalog.GetString ("Today");
 136                         else if (dt == today + one_day)
 137                                 return Catalog.GetString ("Tomorrow");
 138
 139                         TimeSpan span;
 140
 141                         if (today > dt)
 142                                 span = today - dt;
 143                         else
 144                                 span = dt - today;
 145
 146                         if (span.TotalDays < 7)
 147                                 return dt.ToString ("dddd"); // "Tuesday"
 148                         else if (dt.Year == today.Year || span.TotalDays < 180)
 149                                 return dt.ToString (month_day_pattern);
 150                         else
 151                                 return dt.ToString (year_month_pattern);
 152                 }
 153
 154                 public static string NiceShortDate (string timestamp)
 155                 {
 156                         DateTime dt;
 157
 158                         try {
 159                                 dt = ParseTimestamp (timestamp);
 160                         } catch {
 161                                 return "";
 162                         }
 163
 164                         return NiceShortDate (dt);
 165                 }
 166
 167                 public static string NiceShortDate (DateTime dt)
 168                 {
 169                         // "Jul 4" and "Jan 2001", respectively.
 170                         return NiceDatePattern (dt, ShortMonthDayPattern, ShortYearMonthPattern);
 171                 }
 172
 173                 public static string NiceLongDate (string timestamp)
 174                 {
 175                         DateTime dt;
 176
 177                         try {
 178                                 dt = ParseTimestamp (timestamp);
 179                         } catch {
 180                                 return "";
 181                         }
 182
 183                         return NiceLongDate (dt);
 184                 }
 185
 186                 public static string NiceLongDate (DateTime dt)
 187                 {
 188                         // "July 4" and "January 7, 2001", respectively.
 189                         return NiceDatePattern (dt, MonthDayPattern, LongDatePattern);
 190                 }
 191
 192                 public static string NiceVeryLongDate (string timestamp)
 193                 {
 194                         DateTime dt;
 195
 196                         try {
 197                                 dt = ParseTimestamp (timestamp);
 198                         } catch {
 199                                 return "";
 200                         }
 201
 202                         return NiceVeryLongDate (dt);
 203                 }
 204
 205                 public static string NiceVeryLongDate (DateTime dt)
 206                 {
 207                         if (dt.Year <= 1970)
 208                                 return "-";
 209
 210                         dt = dt.ToLocalTime ().Date;
 211                         DateTime today = DateTime.Today;
 212                         TimeSpan one_day = new TimeSpan (TimeSpan.TicksPerDay);
 213
 214                         if (dt == today - one_day)
 215                                 return Catalog.GetString ("Yesterday");
 216                         else if (dt == today)
 217                                 return Catalog.GetString ("Today");
 218                         else if (dt == today + one_day)
 219                                 return Catalog.GetString ("Tomorrow");
 220
 221                         TimeSpan span;
 222                         bool future;
 223
 224                         if (today > dt) {
 225                                 span = today - dt;
 226                                 future = false;
 227                         } else {
 228                                 span = dt - today;
 229                                 future = true;
 230                         }
 231
 232                         if (span.TotalDays < 7)
 233                                 return dt.ToString ("dddd"); // "Tuesday"
 234                         else if (span.TotalDays < 30 && ! future)
 235                                 return String.Format (Catalog.GetPluralString ("{0} week ago", "{0} weeks ago", span.Days / 7) + " ({1:MMMM d, yyyy})", span.Days / 7, dt);
 236                         else if (span.TotalDays < 30 && future)
 237                                 return String.Format (Catalog.GetPluralString ("In {0} week", "In {0} weeks", span.Days / 7) + " {1:MMMM d, yyyy})", span.Days / 7, dt);
 238                         else if (span.TotalDays < 365 + 180 && ! future) // Let's say a year and a half to stop saying months
 239                                 return String.Format (Catalog.GetPluralString ("{0} month ago", "{0} months ago", span.Days / 30) + " ({1:MMMM d, yyyy})", span.Days / 30, dt);
 240                         else if (span.TotalDays < 365 + 180 && future)
 241                                 return String.Format (Catalog.GetPluralString ("In {0} month", "In {0} months", span.Days / 30) + " ({1:MMMM d, yyyy})", span.Days / 30, dt);
 242                         else if (! future)
 243                                 return String.Format (Catalog.GetPluralString ("{0} year ago", "{0} years ago", span.Days / 365) + " ({1:MMMM d, yyyy})", span.Days / 365, dt);
 244                         else
 245                                 return String.Format (Catalog.GetPluralString ("In {0} year", "In {0} years", span.Days / 365) + " ({1:MMMM d, yyyy})", span.Days / 365, dt);
 246                 }
 247         }
 248 }