view/aaTreeView.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent tw=79 ft=cpp: */
   3 /*
   4  * Copyright (C) 2007,2008 Sergey Yanovich <ynvich@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include "xpcom-config.h"
  23
  24 #include "nsStringAPI.h"
  25 #include "nsIDOMElement.h"
  26 #include "nsIDOMNode.h"
  27 #include "nsIDOMDocument.h"
  28 #include "nsIDOMXULElement.h"
  29 #include "nsIInterfaceRequestorUtils.h"
  30 #include "nsISHistory.h"
  31 #include "nsServiceManagerUtils.h"
  32 #include "nsIObserverService.h"
  33 #include "nsComponentManagerUtils.h"
  34
  35 /* Unfrozen API */
  36 #include "nsITreeSelection.h"
  37 #include "nsITreeColumns.h"
  38 #include "nsITreeBoxObject.h"
  39 #include "nsIArray.h"
  40 #include "nsArrayUtils.h"
  41 #include "nsClassHashtable.h"
  42
  43 /* Project includes */
  44 #include "aaTreeView.h"
  45 #include "aaISession.h"
  46 #include "aaISqlTransaction.h"
  47 #include "aaISqlRequest.h"
  48 #include "aaBaseLoaders.h"
  49
  50 #include "aaIOrderCondition.h"
  51 #include "aaIFilterCondition.h"
  52 #include "aaConditionKeys.h"
  53 #include "aaISqlFilter.h"
  54
  55 /*******************************************************************/
  56 class CTreeViewFilters : public aaITreeViewFilters
  57 {
  58 public:
  59   class CTreeViewFilter
  60   {
  61   public:
  62     CTreeViewFilter(nsITreeColumn* col, const nsAString& param)
  63       : mColumn(col)
  64       , mParam(param)
  65     {
  66     }
  67     ~CTreeViewFilter() {
  68     }
  69   public:
  70     NS_IMETHOD GetColumn(nsITreeColumn** col) {
  71       NS_ENSURE_ARG_POINTER(col);
  72       NS_IF_ADDREF(*col = mColumn);
  73       return NS_OK;
  74     }
  75     NS_IMETHOD GetParam(nsAString& param) {
  76       param.Truncate();
  77       param = mParam;
  78       return NS_OK;
  79     }
  80   protected:
  81     nsCOMPtr<nsITreeColumn> mColumn;
  82     nsAutoString mParam;
  83   };
  84 public:
  85   CTreeViewFilters();
  86   NS_DECL_ISUPPORTS
  87   NS_DECL_AAITREEVIEWFILTERS
  88 protected:
  89   ~CTreeViewFilters();
  90 protected:
  91   typedef nsClassHashtable<nsUint32HashKey, CTreeViewFilter> aaFilterHashtable;
  92   aaFilterHashtable mContainer;
  93 };
  94
  95 NS_IMPL_ISUPPORTS1(CTreeViewFilters, aaITreeViewFilters)
  96
  97 CTreeViewFilters::CTreeViewFilters() {
  98   mContainer.Init();
  99 }
 100
 101 CTreeViewFilters::~CTreeViewFilters() {
 102 }
 103
 104 NS_IMETHODIMP
 105   CTreeViewFilters::AddFilter(PRInt16 type, nsITreeColumn* col, const nsAString& param)
 106 {
 107   NS_ENSURE_ARG_POINTER(col);
 108   if (!mContainer.Put(PRUint32(type), new CTreeViewFilter(col, param))) {
 109     return NS_ERROR_FAILURE;
 110   }
 111   return NS_OK;
 112 }
 113
 114 NS_IMETHODIMP
 115   CTreeViewFilters::Clear()
 116 {
 117   mContainer.Clear();
 118   return NS_OK;
 119 }
 120
 121 PLDHashOperator EnumFunc(const PRUint32& type, nsAutoPtr<CTreeViewFilters::CTreeViewFilter>& filter, void* userArg)
 122 {
 123   if (nsnull != userArg) {
 124     nsCOMPtr<nsITreeColumn> col;
 125     nsAutoString param;
 126     aaITreeFilterObserver* pObserver = (aaITreeFilterObserver*)userArg;
 127     if (NS_SUCCEEDED(filter->GetColumn(getter_AddRefs(col))) && NS_SUCCEEDED(filter->GetParam(param))) {
 128       PRBool moveNext = PR_TRUE;
 129       if (NS_SUCCEEDED(pObserver->Next(PRInt16(type), col, param, &moveNext))) {
 130         return moveNext ? PL_DHASH_NEXT : PL_DHASH_STOP;
 131       }
 132     }
 133   }
 134   return PL_DHASH_STOP;
 135 }
 136
 137 NS_IMETHODIMP
 138   CTreeViewFilters::Observe(aaITreeFilterObserver *observer)
 139 {
 140   NS_ENSURE_ARG_POINTER(observer);
 141   mContainer.Enumerate((aaFilterHashtable::EnumFunction)&EnumFunc, observer);
 142   return NS_OK;
 143 }
 144
 145 NS_IMETHODIMP
 146   CTreeViewFilters::IsExist(PRInt16 type, PRBool *_retval NS_OUTPARAM)
 147 {
 148   nsresult rc = NS_OK;
 149   NS_ENSURE_ARG_POINTER(_retval);
 150   *_retval = PR_FALSE;
 151   CTreeViewFilter* pFilter = nsnull;
 152   if (mContainer.Get(type, &pFilter)) {
 153     *_retval = PR_TRUE;
 154   }
 155   return rc;
 156 }
 157
 158 NS_IMETHODIMP
 159   CTreeViewFilters::GetFilter(PRInt16 type, nsITreeColumn **col NS_OUTPARAM, nsAString & param NS_OUTPARAM)
 160 {
 161   nsresult rc = NS_OK;
 162   CTreeViewFilter* pFilter = nsnull;
 163   NS_ENSURE_ARG_POINTER(col);
 164   if (!mContainer.Get(type, &pFilter)) {
 165     return NS_ERROR_INVALID_ARG;
 166   }
 167   param.Truncate();
 168   NS_ENSURE_SUCCESS(rc = pFilter->GetColumn(col), rc);
 169   NS_ENSURE_SUCCESS(rc = pFilter->GetParam(param), rc);
 170   return rc;
 171 }
 172 /*******************************************************************/
 173
 174 aaTreeView::aaTreeView()
 175   : mFlags(0)
 176   , mOldRowCount(0)
 177   , mFilters(nsnull)
 178 {
 179 }
 180
 181 aaTreeView::~aaTreeView()
 182 {
 183 }
 184
 185 nsresult
 186 aaTreeView::Init(nsISupports *aParam)
 187 {
 188   nsresult rv;
 189   mSession = do_QueryInterface(aParam, &rv);
 190   NS_ENSURE_SUCCESS(rv, rv);
 191
 192   return NS_OK;
 193 }
 194
 195 NS_IMPL_ISUPPORTS3(aaTreeView,
 196                    aaIDataTreeView,
 197                    nsITreeView,
 198                    aaITreeFilterObserver)
 199
 200 NS_IMETHODIMP
 201 aaTreeView::GetRowCount(PRInt32 *aRowCount)
 202 {
 203   NS_ENSURE_ARG_POINTER(aRowCount);
 204   *aRowCount = 0;
 205   if (! mDataSet)
 206     return NS_OK;
 207
 208   return mDataSet->GetLength((PRUint32 *) aRowCount);
 209 }
 210
 211 NS_IMETHODIMP
 212 aaTreeView::GetSelection(nsITreeSelection * *aSelection)
 213 {
 214   NS_ENSURE_ARG_POINTER( aSelection );
 215   NS_IF_ADDREF(*aSelection = mSelection);
 216   return NS_OK;
 217 }
 218 NS_IMETHODIMP
 219 aaTreeView::SetSelection(nsITreeSelection * aSelection)
 220 {
 221   mSelection = aSelection;
 222
 223   return NS_OK;
 224 }
 225
 226 NS_IMETHODIMP
 227 aaTreeView::GetRowProperties(PRInt32 index, nsISupportsArray *properties)
 228 {
 229     return NS_ERROR_NOT_IMPLEMENTED;
 230 }
 231
 232 NS_IMETHODIMP
 233 aaTreeView::GetCellProperties(PRInt32 row, nsITreeColumn *col, nsISupportsArray *properties)
 234 {
 235   return NS_ERROR_NOT_IMPLEMENTED;
 236 }
 237
 238 NS_IMETHODIMP
 239 aaTreeView::GetColumnProperties(nsITreeColumn *col, nsISupportsArray *properties)
 240 {
 241     return NS_ERROR_NOT_IMPLEMENTED;
 242 }
 243
 244 NS_IMETHODIMP
 245 aaTreeView::IsContainer(PRInt32 index, PRBool *_retval)
 246 {
 247   NS_ENSURE_ARG_POINTER(_retval);
 248   *_retval = PR_FALSE;
 249   return NS_OK;
 250 }
 251
 252 NS_IMETHODIMP
 253 aaTreeView::IsContainerOpen(PRInt32 index, PRBool *_retval)
 254 {
 255     return NS_ERROR_NOT_IMPLEMENTED;
 256 }
 257
 258 NS_IMETHODIMP
 259 aaTreeView::IsContainerEmpty(PRInt32 index, PRBool *_retval)
 260 {
 261     return NS_ERROR_NOT_IMPLEMENTED;
 262 }
 263
 264 NS_IMETHODIMP
 265 aaTreeView::IsSeparator(PRInt32 index, PRBool *_retval)
 266 {
 267   NS_ENSURE_ARG_POINTER(_retval);
 268   *_retval = PR_FALSE;
 269   return NS_OK;
 270 }
 271
 272 NS_IMETHODIMP
 273 aaTreeView::IsSorted(PRBool *_retval)
 274 {
 275     return NS_ERROR_NOT_IMPLEMENTED;
 276 }
 277
 278 NS_IMETHODIMP
 279 aaTreeView::CanDrop(PRInt32 index, PRInt32 orientation,
 280     nsIDOMDataTransfer *dataTransfer, PRBool *_retval NS_OUTPARAM)
 281 {
 282     return NS_ERROR_NOT_IMPLEMENTED;
 283 }
 284
 285 NS_IMETHODIMP
 286 aaTreeView::Drop(PRInt32 row, PRInt32 orientation,
 287     nsIDOMDataTransfer *dataTransfer)
 288 {
 289     return NS_ERROR_NOT_IMPLEMENTED;
 290 }
 291
 292 NS_IMETHODIMP
 293 aaTreeView::GetParentIndex(PRInt32 rowIndex, PRInt32 *_retval)
 294 {
 295     return NS_ERROR_NOT_IMPLEMENTED;
 296 }
 297
 298 NS_IMETHODIMP
 299 aaTreeView::HasNextSibling(PRInt32 rowIndex, PRInt32 afterIndex, PRBool *_retval)
 300 {
 301   NS_ENSURE_ARG_POINTER(_retval);
 302   nsresult rv;
 303   PRInt32 count;
 304   rv = GetRowCount(&count);
 305   NS_ENSURE_SUCCESS(rv, rv);
 306   if (rowIndex == afterIndex && rowIndex < count) {
 307     *_retval = PR_TRUE;
 308   } else {
 309     *_retval = PR_FALSE;
 310   }
 311   return NS_OK;
 312 }
 313
 314 NS_IMETHODIMP
 315 aaTreeView::GetLevel(PRInt32 index, PRInt32 *_retval)
 316 {
 317   NS_ENSURE_ARG_POINTER(_retval);
 318   *_retval = 0;
 319   return NS_OK;
 320 }
 321
 322 NS_IMETHODIMP
 323 aaTreeView::GetImageSrc(PRInt32 row, nsITreeColumn *col, nsAString & _retval)
 324 {
 325     return NS_ERROR_NOT_IMPLEMENTED;
 326 }
 327
 328 NS_IMETHODIMP
 329 aaTreeView::GetProgressMode(PRInt32 row, nsITreeColumn *col, PRInt32 *_retval)
 330 {
 331     return NS_ERROR_NOT_IMPLEMENTED;
 332 }
 333
 334 NS_IMETHODIMP
 335 aaTreeView::GetCellValue(PRInt32 row, nsITreeColumn *col, nsAString & _retval)
 336 {
 337     return NS_ERROR_NOT_IMPLEMENTED;
 338 }
 339
 340 NS_IMETHODIMP
 341 aaTreeView::GetCellText(PRInt32 row, nsITreeColumn *col, nsAString & _retval)
 342 {
 343   /**
 344    * There may be a bug in <tree> implementation. This function is
 345    * occasionally called after mTree is detached by SetTree(nsnull);
 346    */
 347   NS_ENSURE_TRUE(mDataSet, NS_ERROR_NOT_INITIALIZED);
 348   NS_ENSURE_TRUE(row >= 0, NS_ERROR_INVALID_ARG);
 349   return doGetCellText(row, col, _retval);
 350 }
 351
 352 NS_IMETHODIMP
 353 aaTreeView::SetTree(nsITreeBoxObject *tree)
 354 {
 355   mTree = tree;
 356   return NS_OK;
 357 }
 358
 359 NS_IMETHODIMP
 360 aaTreeView::ToggleOpenState(PRInt32 index)
 361 {
 362     return NS_ERROR_NOT_IMPLEMENTED;
 363 }
 364
 365 NS_IMETHODIMP
 366 aaTreeView::CycleHeader(nsITreeColumn *col)
 367 {
 368   //when column clicked, method was called by treecol handler
 369   return NS_OK;//NS_ERROR_NOT_IMPLEMENTED;
 370 }
 371
 372 NS_IMETHODIMP
 373 aaTreeView::SelectionChanged()
 374 {
 375   return NS_OK;
 376 }
 377
 378 NS_IMETHODIMP
 379 aaTreeView::CycleCell(PRInt32 row, nsITreeColumn *col)
 380 {
 381     return NS_ERROR_NOT_IMPLEMENTED;
 382 }
 383
 384 NS_IMETHODIMP
 385 aaTreeView::IsEditable(PRInt32 row, nsITreeColumn *col, PRBool *_retval)
 386 {
 387     return NS_ERROR_NOT_IMPLEMENTED;
 388 }
 389
 390 NS_IMETHODIMP
 391 aaTreeView::IsSelectable(PRInt32 row, nsITreeColumn *col, PRBool *_retval)
 392 {
 393   NS_ENSURE_ARG_POINTER(_retval);
 394   *_retval = PR_TRUE;
 395   return NS_OK;
 396 }
 397
 398 NS_IMETHODIMP
 399 aaTreeView::SetCellValue(PRInt32 row, nsITreeColumn *col, const nsAString & value)
 400 {
 401     return NS_ERROR_NOT_IMPLEMENTED;
 402 }
 403
 404 NS_IMETHODIMP
 405 aaTreeView::SetCellText(PRInt32 row, nsITreeColumn *col, const nsAString & value)
 406 {
 407     return NS_ERROR_NOT_IMPLEMENTED;
 408 }
 409
 410 NS_IMETHODIMP
 411 aaTreeView::PerformAction(const PRUnichar *action)
 412 {
 413     return NS_ERROR_NOT_IMPLEMENTED;
 414 }
 415
 416 NS_IMETHODIMP
 417 aaTreeView::PerformActionOnRow(const PRUnichar *action, PRInt32 row)
 418 {
 419     return NS_ERROR_NOT_IMPLEMENTED;
 420 }
 421
 422 NS_IMETHODIMP
 423 aaTreeView::PerformActionOnCell(const PRUnichar *action, PRInt32 row, nsITreeColumn *col)
 424 {
 425     return NS_ERROR_NOT_IMPLEMENTED;
 426 }
 427
 428 /* aaIDataTreeView */
 429 NS_IMETHODIMP
 430 aaTreeView::GetDataSet(nsIArray * * aDataSet)
 431 {
 432   NS_ENSURE_ARG_POINTER(aDataSet);
 433   NS_IF_ADDREF(*aDataSet = mDataSet);
 434   return NS_OK;
 435 }
 436
 437 NS_IMETHODIMP aaTreeView::GetOldRowCount(PRInt32* aRowCount) {
 438   *aRowCount = mOldRowCount;
 439   return NS_OK;
 440 }
 441
 442 NS_IMETHODIMP aaTreeView::RowCountChanged(PRInt32 aOldRowCount, PRInt32 aNewRowCount) {
 443   if (mOldRowCount == aOldRowCount) {
 444     mOldRowCount = aNewRowCount;
 445     return NS_OK;
 446   }
 447   return NS_ERROR_INVALID_ARG;
 448 }
 449
 450 NS_IMETHODIMP
 451 aaTreeView::Update(nsISupports *aParam = 0)
 452 {
 453   NS_ENSURE_TRUE(mDataLoader || mComplexLoader, NS_ERROR_NOT_INITIALIZED);
 454   nsresult rv;
 455   PRInt32 oldCount = 0;
 456   PRInt32 newRowCount = 0;
 457
 458
 459   rv = GetOldRowCount(&oldCount);
 460   NS_ENSURE_SUCCESS(rv, rv);
 461
 462   if (mTree) {
 463     mTree->RowCountChanged(0, - oldCount);
 464   }
 465
 466   rv = buildFilter(aParam);
 467   NS_ENSURE_SUCCESS(rv, rv);
 468
 469   if (mDataLoader) {
 470     rv = mDataLoader->SetFilter(mFilter);
 471     NS_ENSURE_SUCCESS(rv, rv);
 472
 473     rv = mSession->Load(mDataLoader, getter_AddRefs(mDataSet));
 474     NS_ENSURE_SUCCESS(rv, rv);
 475
 476     rv = postLoadHandler();
 477     NS_ENSURE_SUCCESS(rv, rv);
 478   }
 479   else {
 480     nsCOMPtr<nsISupports> supReturn;
 481
 482     rv = mComplexLoader->SetParam(mFilter);
 483     NS_ENSURE_SUCCESS(rv, rv);
 484
 485     rv = mSession->Execute(mComplexLoader, getter_AddRefs(supReturn));
 486     NS_ENSURE_SUCCESS(rv, rv);
 487     NS_ENSURE_TRUE(supReturn, NS_ERROR_UNEXPECTED);
 488
 489     rv = supReturn->QueryInterface(NS_GET_IID(nsIArray), getter_AddRefs(mDataSet));
 490     NS_ENSURE_SUCCESS(rv, rv);
 491   }
 492
 493   rv = GetRowCount(&newRowCount);
 494   NS_ENSURE_SUCCESS(rv, rv);
 495
 496   rv = RowCountChanged(oldCount, newRowCount);
 497   NS_ENSURE_SUCCESS(rv, rv);
 498
 499   if (mTree) {
 500     mTree->RowCountChanged(0, newRowCount);
 501   }
 502
 503   nsCOMPtr<nsIObserverService> broadcaster = do_GetService("@mozilla.org/observer-service;1");
 504   NS_ENSURE_TRUE(broadcaster, NS_OK);
 505   broadcaster->NotifyObservers(reinterpret_cast<nsISupports*>(this), "tree-view-load", nsnull);
 506
 507   rv = dataLoadSuccess();
 508   NS_ENSURE_SUCCESS(rv, rv);
 509
 510   return NS_OK;
 511 }
 512
 513 NS_IMETHODIMP
 514 aaTreeView::GetFlags(PRUint32 *aFlags)
 515 {
 516   NS_ENSURE_ARG_POINTER(aFlags);
 517   *aFlags = mFlags;
 518   return NS_OK;
 519 }
 520 NS_IMETHODIMP
 521 aaTreeView::SetFlags(PRUint32 aFlags)
 522 {
 523   PRBool needUpdate = (aFlags != mFlags);
 524   mFlags = aFlags;
 525   if (NS_LIKELY( needUpdate && mTree )) {
 526     mTree->Invalidate();
 527     nsCOMPtr<nsIObserverService> broadcaster = do_GetService(
 528         "@mozilla.org/observer-service;1");
 529     NS_ENSURE_TRUE(broadcaster, NS_OK);
 530     broadcaster->NotifyObservers(reinterpret_cast<nsISupports*>(this), "tree-flags-change", nsnull);
 531   }
 532   return NS_OK;
 533 }
 534
 535 /* Protected methods */
 536 nsresult
 537 aaTreeView::postLoadHandler()
 538 {
 539   return NS_OK;
 540 }
 541
 542 PRInt32
 543 aaTreeView::getColumnIndex(nsITreeColumn *col, PRUint32 colPtrSz)
 544 {
 545   nsresult rv;
 546   NS_ENSURE_TRUE(col, -1);
 547
 548   PRInt32 ci;
 549   rv = col->GetIndex(&ci);
 550   NS_ENSURE_SUCCESS(rv, -1);
 551
 552   NS_ENSURE_TRUE(ci >= 0 && ci < (PRInt32) (colPtrSz / sizeof(int *)), -1);
 553
 554   return ci;
 555 }
 556
 557 NS_IMETHODIMP
 558   aaTreeView::GetFilters(aaITreeViewFilters **aFilters)
 559 {
 560   NS_ENSURE_ARG_POINTER(aFilters);
 561   if (!mFilters) {
 562     //mFilters
 563     (new CTreeViewFilters)->QueryInterface(NS_GET_IID(aaITreeViewFilters), getter_AddRefs(mFilters));
 564     NS_ENSURE_TRUE(mFilters, NS_ERROR_NULL_POINTER);
 565   }
 566   if (NS_IF_ADDREF(mFilters)) {
 567     *aFilters = mFilters;
 568   } else {
 569     *aFilters = nsnull;
 570     return NS_ERROR_FAILURE;
 571   }
 572   return NS_OK;
 573 }
 574
 575 NS_IMETHODIMP
 576   aaTreeView::Next(PRInt16 type, nsITreeColumn *col, const nsAString & param, PRBool *_retval)
 577 {
 578   nsresult rc = NS_OK;
 579   NS_ENSURE_ARG_POINTER(col);
 580   NS_ENSURE_ARG_POINTER(_retval);
 581   NS_ENSURE_TRUE(mFilter, NS_ERROR_NOT_INITIALIZED);
 582   *_retval = PR_FALSE;
 583   if (PRInt16(aaITreeViewFilters::FILTER_SORT) == type) {
 584     nsCOMPtr<aaIOrderCondition> order;
 585     nsCAutoString name;
 586     //do create order condition
 587     rc = createOrderCondition(col, param, getter_AddRefs(order));
 588     NS_ENSURE_SUCCESS(rc, rc);
 589     //do get condition name
 590     rc = order->GetConditionName(name);
 591     NS_ENSURE_SUCCESS(rc, rc);
 592     //do add order to filter
 593     rc = mFilter->AddParam(name, order);
 594     NS_ENSURE_SUCCESS(rc, rc);
 595   } else if(PRInt16(aaITreeViewFilters::FILTER_FILTER) == type) {
 596     nsCOMPtr<aaIFilterCondition> filter;
 597     nsCAutoString name;
 598     //do create order condition
 599     rc = createFilterCondition(col, param, getter_AddRefs(filter));
 600     NS_ENSURE_SUCCESS(rc, rc);
 601     //do get condition name
 602     rc = filter->GetConditionName(name);
 603     NS_ENSURE_SUCCESS(rc, rc);
 604     //do add order to filter
 605     rc = mFilter->AddParam(name, filter);
 606     NS_ENSURE_SUCCESS(rc, rc);
 607   } else {
 608     return NS_ERROR_INVALID_ARG;
 609   }
 610   *_retval = PR_TRUE;
 611   return rc;
 612 }
 613
 614 NS_IMETHODIMP
 615   aaTreeView::buildFilter(nsISupports* aParam)
 616 {
 617   nsresult rc = NS_OK;
 618   if (mFilter) {
 619     mFilter = nsnull;
 620   }
 621
 622   if (mFilters || aParam) {
 623     mFilter = do_CreateInstance(AA_SQLFILTER_CONTRACT, &rc);
 624     NS_ENSURE_SUCCESS(rc, rc);
 625   }
 626
 627   if (mFilters) {
 628     nsCOMPtr<aaITreeFilterObserver> pObserver;
 629     this->QueryInterface(NS_GET_IID(aaITreeFilterObserver), getter_AddRefs(pObserver));
 630     NS_ENSURE_SUCCESS(rc, rc);
 631     //do observe params
 632     rc = mFilters->Observe(pObserver);
 633     NS_ENSURE_SUCCESS(rc, rc);
 634   }
 635
 636   if (aParam) {
 637     //add param to filter
 638     rc = mFilter->SetInterface(aParam->GetIID(), aParam);
 639     NS_ENSURE_SUCCESS(rc, rc);
 640   }
 641   return rc;
 642 }
 643
 644 nsresult
 645   aaTreeView::createOrderCondition(nsITreeColumn* col, const nsAString& param, aaIOrderCondition** _retval)
 646 {
 647   nsresult rc = NS_OK;
 648   nsCAutoString column;
 649   nsCOMPtr<aaIOrderCondition> order;
 650
 651   NS_ENSURE_ARG_POINTER(col);
 652   NS_ENSURE_ARG_POINTER(_retval);
 653   NS_ENSURE_ARG_POINTER(!param.IsEmpty());
 654
 655   order = do_CreateInstance(AA_ORDER_CONDITION_CONTRACTID, &rc);
 656   NS_ENSURE_SUCCESS(rc, rc);
 657
 658   rc = convertSortColumnToString(col, column);
 659   NS_ENSURE_SUCCESS(rc, rc);
 660
 661   rc = order->AddOrder(column, (param.Compare(NS_LITERAL_STRING("ascending")) == 0 ? PRInt16(aaIOrderCondition::SORT_ASC) : PRInt16(aaIOrderCondition::SORT_DESC)));
 662   NS_ENSURE_SUCCESS(rc, rc);
 663
 664   if (NS_IF_ADDREF(order)) {
 665     *_retval = order;
 666   } else {
 667     *_retval = nsnull;
 668     return NS_ERROR_UNEXPECTED;
 669   }
 670   return rc;
 671 }
 672
 673 nsresult
 674   aaTreeView::createFilterCondition(nsITreeColumn* col, const nsAString& param, aaIFilterCondition** _retval)
 675 {
 676   nsresult rc = NS_OK;
 677   nsCAutoString column;
 678   nsCOMPtr<aaIFilterCondition> filter;
 679
 680   NS_ENSURE_ARG_POINTER(col);
 681   NS_ENSURE_ARG_POINTER(_retval);
 682   NS_ENSURE_ARG_POINTER(!param.IsEmpty());
 683
 684   filter = do_CreateInstance(AA_FILTER_CONDITION_CONTRACTID, &rc);
 685   NS_ENSURE_SUCCESS(rc, rc);
 686
 687   rc = convertSortColumnToString(col, column);
 688   NS_ENSURE_SUCCESS(rc, rc);
 689
 690   rc = filter->AddFilter(column, NS_ConvertUTF16toUTF8(param));
 691   NS_ENSURE_SUCCESS(rc, rc);
 692
 693   if (NS_IF_ADDREF(filter)) {
 694     *_retval = filter;
 695   } else {
 696     *_retval = nsnull;
 697     return NS_ERROR_UNEXPECTED;
 698   }
 699   return rc;
 700 }
 701
 702 NS_IMETHODIMP
 703   aaTreeView::dataLoadSuccess()
 704 {
 705   return NS_OK;
 706 }