Tiles/TileHitCollection.cs

   1 //
   2 // TileHitCollection.cs
   3 //
   4 // Copyright (C) 2004 Novell, Inc.
   5 //
   6
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a
   9 // copy of this software and associated documentation files (the "Software"),
  10 // to deal in the Software without restriction, including without limitation
  11 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12 // and/or sell copies of the Software, and to permit persons to whom the
  13 // Software is furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in
  16 // all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24 // DEALINGS IN THE SOFTWARE.
  25 //
  26
  27 using System;
  28 using System.Collections;
  29
  30 namespace Beagle.Tile {
  31
  32         [TileStyle (Resource="template-page.css")]
  33         public class TileHitCollection : Tile {
  34
  35                 public TileHitCollection () {
  36                 }
  37
  38                 private class HitTilePair : IComparable {
  39                         Hit hit;
  40                         Tile tile;
  41
  42                         public HitTilePair (Hit _hit, Tile _tile)
  43                         {
  44                                 hit = _hit;
  45                                 tile = _tile;
  46                         }
  47
  48                         public Beagle.Hit Hit {
  49                                 get { return hit; }
  50                         }
  51
  52                         public Tile Tile {
  53                                 get { return tile; }
  54                         }
  55
  56                         public int CompareTo (object obj)
  57                         {
  58                                 HitTilePair other = (HitTilePair) obj;
  59                                 return hit.CompareTo (other.hit);
  60                         }
  61                 }
  62
  63                 private ArrayList all_hits = new ArrayList ();
  64                 private ArrayList hits = new ArrayList ();
  65                 int firstDisplayed = 0;
  66                 int maxDisplayed = 5;
  67
  68                 Template head_template;
  69                 Template foot_template;
  70
  71                 public double MaxScore {
  72                         get {
  73                                 if (all_hits.Count == 0)
  74                                         return 0;
  75                                 HitTilePair pair = (HitTilePair) all_hits [0];
  76                                 return pair.Hit.Score;
  77                         }
  78                 }
  79
  80                 public int FirstDisplayed {
  81                         get { return firstDisplayed; }
  82                 }
  83
  84                 public int LastDisplayed {
  85                         get { return Math.Min (firstDisplayed + maxDisplayed, hits.Count) - 1; }
  86                 }
  87
  88                 public int NumDisplayableResults {
  89                         get { return hits.Count; }
  90                 }
  91
  92                 public int NumResults {
  93                         get { return all_hits.Count; }
  94                 }
  95
  96                 public bool CanPageForward {
  97                         get { return LastDisplayed != (hits.Count - 1); }
  98                 }
  99
 100                 [TileAction]
 101                 public void PageFirst ()
 102                 {
 103                         firstDisplayed = 0;
 104                         Changed ();
 105                 }
 106
 107                 [TileAction]
 108                 public void PageForward ()
 109                 {
 110                         firstDisplayed += maxDisplayed;
 111                         if (firstDisplayed < 0)
 112                                 firstDisplayed = 0;
 113                         Changed ();
 114                 }
 115
 116                 public bool CanPageBack {
 117                         get { return FirstDisplayed > 0; }
 118                 }
 119
 120                 [TileAction]
 121                 public void PageBack ()
 122                 {
 123                         firstDisplayed -= maxDisplayed;
 124                         if (firstDisplayed < 0)
 125                                 firstDisplayed = 0;
 126                         Changed ();
 127                 }
 128
 129                 public void Clear ()
 130                 {
 131                         bool changed = false;
 132                         lock (this) {
 133                                 if (all_hits.Count > 0) {
 134                                         all_hits.Clear ();
 135                                         firstDisplayed = 0;
 136                                         changed = true;
 137                                 }
 138                                 if (hits.Count > 0) {
 139                                         hits.Clear ();
 140                                         firstDisplayed = 0;
 141                                         changed = true;
 142                                 }
 143                         }
 144                         if (changed)
 145                                 Changed ();
 146                 }
 147
 148                 private bool InsertDisplayable (HitTilePair pair)
 149                 {
 150                         int i = hits.BinarySearch (pair);
 151
 152                         hits.Insert (i < 0 ? ~i : i, pair);
 153                         if (i == 0 || i < LastDisplayed) {
 154                                 Changed ();
 155                                 return true;
 156                         }
 157
 158                         return false;
 159                 }
 160
 161                 public bool Add (Hit hit, Tile tile)
 162                 {
 163                         bool changed = false;
 164
 165                         HitTilePair pair = new HitTilePair (hit, tile);
 166                         int i = all_hits.BinarySearch (pair);
 167                         all_hits.Insert (i < 0 ? ~i : i, pair);
 168                         if (i == 0 || i < LastDisplayed) {
 169                                 Changed ();
 170                                 changed = true;
 171                         }
 172
 173                         if (SourceIsDisplayable (hit)) {
 174                                 if (InsertDisplayable (pair))
 175                                         changed = true;
 176                         }
 177
 178                         return changed;
 179                 }
 180
 181                 public bool Subtract (Uri uri)
 182                 {
 183                         bool removed = false;
 184
 185                         for (int i = 0; i < all_hits.Count; ++i) {
 186                                 HitTilePair pair = (HitTilePair) all_hits [i];
 187                                 if (pair.Hit.Uri.Equals (uri) && pair.Hit.Uri.Fragment == uri.Fragment) {
 188                                         all_hits.Remove (pair);
 189                                         removed = true;
 190                                         break;
 191                                 }
 192                         }
 193
 194                         for (int i = 0; i < hits.Count; ++i) {
 195                                 HitTilePair pair = (HitTilePair) hits [i];
 196                                 if (pair.Hit.Uri.Equals (uri) && pair.Hit.Uri.Fragment == uri.Fragment) {
 197                                         hits.Remove (pair);
 198                                         break;
 199                                 }
 200                         }
 201
 202                         return removed;
 203                 }
 204
 205                 public bool IsEmpty {
 206                         get { return all_hits.Count == 0; }
 207                 }
 208
 209                 private ArrayList hitSources = new ArrayList ();
 210
 211                 public void SetSource (string source)
 212                 {
 213                         Console.WriteLine ("SetSource: {0}", source);
 214
 215                         hitSources = new ArrayList ();
 216
 217                         if (source != null)
 218                                 hitSources.Add (source);
 219
 220                         hits = new ArrayList ();
 221                         for (int i = 0; i < NumResults; i ++) {
 222                                 HitTilePair pair = (HitTilePair) all_hits [i];
 223
 224                                 if (SourceIsDisplayable (pair.Hit)) {
 225                                         InsertDisplayable (pair);
 226                                 } else
 227                                         Console.WriteLine ("{0} -- {1}", pair.Hit.Type, pair.Hit.Uri);
 228                         }
 229
 230                         Changed ();
 231                 }
 232
 233                 public void AddSource (string source)
 234                 {
 235                         hitSources.Add (source);
 236
 237                         for (int i = 0; i < NumDisplayableResults; i ++) {
 238                                 HitTilePair pair = (HitTilePair) hits [i];
 239
 240                                 if (! SourceIsDisplayable (pair.Hit))
 241                                         hits.RemoveAt (i);
 242                         }
 243                 }
 244
 245                 public void SubtractSource (string source)
 246                 {
 247                         hitSources.Remove (source);
 248
 249                         for (int i = 0; i < NumResults; i ++) {
 250                                 HitTilePair pair = (HitTilePair) hits [i];
 251
 252                                 if (pair.Hit.Source != source)
 253                                         continue;
 254
 255                                 int j = hits.BinarySearch (pair);
 256
 257                                 hits.Insert (j < 0 ? ~j : j, pair);
 258                                 if (j == 0 || j < LastDisplayed)
 259                                         Changed ();
 260                         }
 261                 }
 262
 263                 public void ClearSources (string source)
 264                 {
 265                         if (hitSources.Count == 0)
 266                                 return;
 267
 268                         hitSources.Clear ();
 269
 270                         Changed ();
 271                 }
 272
 273                 public bool SourceIsDisplayable (Hit hit)
 274                 {
 275                         if (hitSources.Count == 0)
 276                                 return true;
 277
 278                         if (hitSources.IndexOf (hit.Type) >= 0)
 279                                 return true;
 280
 281                         return false;
 282                 }
 283
 284                 private void RenderTiles (TileRenderContext ctx)
 285                 {
 286                         int i = FirstDisplayed;
 287                         int i1 = LastDisplayed;
 288
 289                         while (i <= i1 && i < NumResults) {
 290                                 HitTilePair pair = (HitTilePair) hits [i];
 291                                 ctx.Tile (pair.Tile);
 292                                 ++i;
 293                         }
 294                 }
 295
 296                 private void PopulateTemplate (Template t)
 297                 {
 298                 }
 299
 300                 public override void Render (TileRenderContext ctx)
 301                 {
 302                         if (head_template == null) {
 303                                 head_template = new Template ("template-head.html");
 304                                 PopulateTemplate (head_template);
 305                         }
 306
 307                         ctx.Write (head_template.ToString ());
 308
 309                         RenderTiles (ctx);
 310
 311                         if (foot_template == null) {
 312                                 foot_template = new Template ("template-foot.html");
 313                                 PopulateTemplate (foot_template);
 314                         }
 315                         ctx.Write (foot_template.ToString ());
 316                 }
 317         }
 318 }