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 using Beagle.Util;
  30
  31 namespace Beagle.Tile {
  32
  33         [TileStyle (Resource="template-page.css")]
  34         public class TileHitCollection : Tile {
  35
  36                 public TileHitCollection () {
  37                 }
  38
  39                 private class HitTilePair : IComparable {
  40                         Hit hit;
  41                         Tile tile;
  42
  43                         public HitTilePair (Hit _hit, Tile _tile)
  44                         {
  45                                 hit = _hit;
  46                                 tile = _tile;
  47                         }
  48
  49                         public Beagle.Hit Hit {
  50                                 get { return hit; }
  51                         }
  52
  53                         public Tile Tile {
  54                                 get { return tile; }
  55                         }
  56
  57                         public int CompareTo (object obj)
  58                         {
  59                                 HitTilePair other = (HitTilePair) obj;
  60                                 return hit.CompareTo (other.hit);
  61                         }
  62                 }
  63
  64                 private ArrayList all_hits = new ArrayList ();
  65                 private ArrayList hits = new ArrayList ();
  66                 int firstDisplayed = 0;
  67                 int maxDisplayed = Conf.Searching.MaxDisplayed;
  68
  69                 Template head_template;
  70                 Template foot_template;
  71
  72                 public double MaxScore {
  73                         get {
  74                                 if (all_hits.Count == 0)
  75                                         return 0;
  76                                 HitTilePair pair = (HitTilePair) all_hits [0];
  77                                 return pair.Hit.Score;
  78                         }
  79                 }
  80
  81                 public int FirstDisplayed {
  82                         get { return firstDisplayed; }
  83                 }
  84
  85                 public int LastDisplayed {
  86                         get { return Math.Min (firstDisplayed + maxDisplayed, hits.Count) - 1; }
  87                 }
  88
  89                 public int NumDisplayableResults {
  90                         get { return hits.Count; }
  91                 }
  92
  93                 public int NumResults {
  94                         get { return all_hits.Count; }
  95                 }
  96
  97                 public bool CanPageForward {
  98                         get { return LastDisplayed != (hits.Count - 1); }
  99                 }
 100
 101                 [TileAction]
 102                 public void PageFirst ()
 103                 {
 104                         firstDisplayed = 0;
 105                         Changed ();
 106                 }
 107
 108                 [TileAction]
 109                 public void PageForward ()
 110                 {
 111                         firstDisplayed += maxDisplayed;
 112                         if (firstDisplayed < 0)
 113                                 firstDisplayed = 0;
 114                         Changed ();
 115                 }
 116
 117                 public bool CanPageBack {
 118                         get { return FirstDisplayed > 0; }
 119                 }
 120
 121                 [TileAction]
 122                 public void PageBack ()
 123                 {
 124                         firstDisplayed -= maxDisplayed;
 125                         if (firstDisplayed < 0)
 126                                 firstDisplayed = 0;
 127                         Changed ();
 128                 }
 129
 130                 public void Clear ()
 131                 {
 132                         bool changed = false;
 133                         lock (this) {
 134                                 if (all_hits.Count > 0) {
 135                                         all_hits.Clear ();
 136                                         firstDisplayed = 0;
 137                                         changed = true;
 138                                 }
 139                                 if (hits.Count > 0) {
 140                                         hits.Clear ();
 141                                         firstDisplayed = 0;
 142                                         changed = true;
 143                                 }
 144                         }
 145                         if (changed)
 146                                 Changed ();
 147                 }
 148
 149                 private bool InsertDisplayable (HitTilePair pair)
 150                 {
 151                         int i = hits.BinarySearch (pair);
 152
 153                         hits.Insert (i < 0 ? ~i : i, pair);
 154                         if (i == 0 || i < LastDisplayed) {
 155                                 Changed ();
 156                                 return true;
 157                         }
 158
 159                         return false;
 160                 }
 161
 162                 public bool Add (Hit hit, Tile tile)
 163                 {
 164                         bool changed = false;
 165
 166                         HitTilePair pair = new HitTilePair (hit, tile);
 167                         int i = all_hits.BinarySearch (pair);
 168                         all_hits.Insert (i < 0 ? ~i : i, pair);
 169                         if (i == 0 || i < LastDisplayed) {
 170                                 Changed ();
 171                                 changed = true;
 172                         }
 173
 174                         if (SourceIsDisplayable (hit)) {
 175                                 if (InsertDisplayable (pair))
 176                                         changed = true;
 177                         }
 178
 179                         return changed;
 180                 }
 181
 182                 public bool Subtract (Uri uri)
 183                 {
 184                         bool removed = false;
 185
 186                         for (int i = 0; i < all_hits.Count; ++i) {
 187                                 HitTilePair pair = (HitTilePair) all_hits [i];
 188                                 if (pair.Hit.Uri.Equals (uri) && pair.Hit.Uri.Fragment == uri.Fragment) {
 189                                         all_hits.Remove (pair);
 190                                         removed = true;
 191                                         break;
 192                                 }
 193                         }
 194
 195                         for (int i = 0; i < hits.Count; ++i) {
 196                                 HitTilePair pair = (HitTilePair) hits [i];
 197                                 if (pair.Hit.Uri.Equals (uri) && pair.Hit.Uri.Fragment == uri.Fragment) {
 198                                         hits.Remove (pair);
 199                                         break;
 200                                 }
 201                         }
 202
 203                         return removed;
 204                 }
 205
 206                 public bool IsEmpty {
 207                         get { return all_hits.Count == 0; }
 208                 }
 209
 210                 private ArrayList hitSources = new ArrayList ();
 211
 212                 public void SetSource (string source)
 213                 {
 214                         Console.WriteLine ("SetSource: {0}", source);
 215
 216                         hitSources = new ArrayList ();
 217
 218                         if (source != null)
 219                                 hitSources.Add (source);
 220
 221                         hits = new ArrayList ();
 222                         for (int i = 0; i < NumResults; i ++) {
 223                                 HitTilePair pair = (HitTilePair) all_hits [i];
 224
 225                                 if (SourceIsDisplayable (pair.Hit)) {
 226                                         InsertDisplayable (pair);
 227                                 } else
 228                                         Console.WriteLine ("{0} -- {1}", pair.Hit.Type, pair.Hit.Uri);
 229                         }
 230
 231                         Changed ();
 232                 }
 233
 234                 public void AddSource (string source)
 235                 {
 236                         hitSources.Add (source);
 237
 238                         for (int i = 0; i < NumDisplayableResults; i ++) {
 239                                 HitTilePair pair = (HitTilePair) hits [i];
 240
 241                                 if (! SourceIsDisplayable (pair.Hit))
 242                                         hits.RemoveAt (i);
 243                         }
 244                 }
 245
 246                 public void SubtractSource (string source)
 247                 {
 248                         hitSources.Remove (source);
 249
 250                         for (int i = 0; i < NumResults; i ++) {
 251                                 HitTilePair pair = (HitTilePair) hits [i];
 252
 253                                 if (pair.Hit.Source != source)
 254                                         continue;
 255
 256                                 int j = hits.BinarySearch (pair);
 257
 258                                 hits.Insert (j < 0 ? ~j : j, pair);
 259                                 if (j == 0 || j < LastDisplayed)
 260                                         Changed ();
 261                         }
 262                 }
 263
 264                 public void ClearSources (string source)
 265                 {
 266                         if (hitSources.Count == 0)
 267                                 return;
 268
 269                         hitSources.Clear ();
 270
 271                         Changed ();
 272                 }
 273
 274                 public bool SourceIsDisplayable (Hit hit)
 275                 {
 276                         if (hitSources.Count == 0)
 277                                 return true;
 278
 279                         if (hitSources.IndexOf (hit.Type) >= 0)
 280                                 return true;
 281
 282                         return false;
 283                 }
 284
 285                 private void RenderTiles (TileRenderContext ctx)
 286                 {
 287                         int i = FirstDisplayed;
 288                         int i1 = LastDisplayed;
 289
 290                         while (i <= i1 && i < NumResults) {
 291                                 HitTilePair pair = (HitTilePair) hits [i];
 292                                 ctx.Tile (pair.Tile);
 293                                 ++i;
 294                         }
 295                 }
 296
 297                 private void PopulateTemplate (Template t)
 298                 {
 299                 }
 300
 301                 public override void Render (TileRenderContext ctx)
 302                 {
 303                         if (head_template == null) {
 304                                 head_template = new Template ("template-head.html");
 305                                 PopulateTemplate (head_template);
 306                         }
 307
 308                         ctx.Write (head_template.ToString ());
 309
 310                         RenderTiles (ctx);
 311
 312                         if (foot_template == null) {
 313                                 foot_template = new Template ("template-foot.html");
 314                                 PopulateTemplate (foot_template);
 315                         }
 316                         ctx.Write (foot_template.ToString ());
 317                 }
 318         }
 319 }