webcit/roomlist.c

   1 /*
   2  * $Id: roomlist.c 7751 2009-08-28 21:13:28Z dothebart $
   3  * room listings and filters.
   4  */
   5
   6 #include "webcit.h"
   7 #include "webserver.h"
   8 #include "roomops.h"
   9
  10 void DeleteFloor(void *vFloor)
  11 {
  12         floor *Floor;
  13         Floor = (floor*) vFloor;
  14         FreeStrBuf(&Floor->Name);
  15         free(Floor);
  16 }
  17
  18 int SortFloorsByNameOrder(const void *vfloor1, const void *vfloor2)
  19 {
  20         floor *f1 = (floor*) GetSearchPayload(vfloor1);
  21         floor *f2 = (floor*) GetSearchPayload(vfloor2);
  22
  23         /* prefer My floor over alpabetical sort */
  24         if (f1->ID == VIRTUAL_MY_FLOOR)
  25                 return 1;
  26         if (f2->ID == VIRTUAL_MY_FLOOR)
  27                 return -1;
  28
  29         return strcmp(ChrPtr(f1->Name), ChrPtr(f2->Name));
  30 }
  31
  32 HashList *GetFloorListHash(StrBuf *Target, WCTemplputParams *TP) {
  33         const char *Err;
  34         StrBuf *Buf;
  35         HashList *floors;
  36         HashPos *it;
  37         floor *Floor;
  38         void *vFloor;
  39         const char *Pos;
  40         int i;
  41         wcsession *WCC = WC;
  42         const char *HashKey;
  43         long HKLen;
  44
  45
  46         if (WCC->Floors != NULL)
  47                 return WCC->Floors;
  48         WCC->Floors = floors = NewHash(1, NULL);
  49         Buf = NewStrBuf();
  50
  51         Floor = malloc(sizeof(floor));
  52         Floor->ID = VIRTUAL_MY_FLOOR;
  53         Floor->Name = NewStrBufPlain(_("My Folders"), -1);
  54         Floor->NRooms = 0;
  55
  56         Put(floors, IKEY(Floor->ID), Floor, DeleteFloor);
  57
  58         serv_puts("LFLR"); /* get floors */
  59         StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err); /* '100', we hope */
  60         if (GetServerStatus(Buf, NULL) == 1)
  61         {
  62                 while(StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err), strcmp(ChrPtr(Buf), "000"))
  63                 {
  64
  65                         Pos = NULL;
  66
  67                         Floor = malloc(sizeof(floor));
  68                         Floor->ID = StrBufExtractNext_long(Buf, &Pos, '|');
  69                         Floor->Name = NewStrBufPlain(NULL, StrLength(Buf));
  70                         StrBufExtract_NextToken(Floor->Name, Buf, &Pos, '|');
  71                         Floor->NRooms = StrBufExtractNext_long(Buf, &Pos, '|');
  72
  73                         Put(floors, IKEY(Floor->ID), Floor, DeleteFloor);
  74                 }
  75         }
  76         FreeStrBuf(&Buf);
  77
  78         /* now lets pre-sort them alphabeticaly. */
  79         i = 1;
  80         SortByPayload(floors, SortFloorsByNameOrder);
  81         it = GetNewHashPos(floors, 0);
  82         while ( GetNextHashPos(floors, it, &HKLen, &HashKey, &vFloor))
  83                 ((floor*) vFloor)->AlphaN = i++;
  84         DeleteHashPos(&it);
  85         SortByHashKeyStr(floors);
  86
  87         return floors;
  88 }
  89
  90 void tmplput_FLOOR_ID(StrBuf *Target, WCTemplputParams *TP)
  91 {
  92         floor *Floor = (floor *)(TP->Context);
  93
  94         StrBufAppendPrintf(Target, "%d", Floor->ID);
  95 }
  96
  97 void tmplput_FLOOR_NAME(StrBuf *Target, WCTemplputParams *TP)
  98 {
  99         floor *Floor = (floor *)(TP->Context);
 100
 101         StrBufAppendTemplate(Target, TP, Floor->Name, 0);
 102 }
 103
 104 void tmplput_FLOOR_NROOMS(StrBuf *Target, WCTemplputParams *TP)
 105 {
 106         floor *Floor = (floor *)(TP->Context);
 107
 108         StrBufAppendPrintf(Target, "%d", Floor->NRooms);
 109 }
 110 HashList *GetRoomListHashLKRA(StrBuf *Target, WCTemplputParams *TP)
 111 {
 112         wcsession *WCC = WC;
 113
 114         if (WCC->Floors == NULL)
 115                 GetFloorListHash(Target, TP);
 116         serv_puts("LKRA");
 117         return GetRoomListHash(Target, TP);
 118 }
 119
 120 void DeleteFolder(void *vFolder)
 121 {
 122         int i;
 123         folder *room;
 124         room = (folder*) vFolder;
 125
 126         FreeStrBuf(&room->name);
 127         ////FreeStrBuf(&room->ACL);
 128
 129         //// FreeStrBuf(&room->room);
 130
 131         if (room->RoomNameParts != NULL)
 132         {
 133                 for (i=0; i < room->nRoomNameParts; i++)
 134                         FreeStrBuf(&room->RoomNameParts[i]);
 135                 free(room->RoomNameParts);
 136         }
 137         free(room);
 138 }
 139
 140
 141 HashList *GetRoomListHash(StrBuf *Target, WCTemplputParams *TP)
 142 {
 143         HashList *rooms;
 144         folder *room;
 145         StrBuf *Buf;
 146         const char *Pos;
 147         const char *Err;
 148         void *vFloor;
 149         wcsession *WCC = WC;
 150         CompareFunc SortIt;
 151         WCTemplputParams SubTP;
 152
 153         Buf = NewStrBuf();
 154         rooms = NewHash(1, NULL);
 155         StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err);
 156         if (GetServerStatus(Buf, NULL) == 1)
 157         {
 158                 while(StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err),
 159                       strcmp(ChrPtr(Buf), "000"))
 160                 {
 161
 162                         Pos = NULL;
 163                         room = (folder*) malloc (sizeof(folder));
 164                         memset(room, 0, sizeof(folder));
 165
 166                         /* Load the base data from the server reply */
 167                         room->name = NewStrBufPlain(NULL, StrLength(Buf));
 168                         StrBufExtract_NextToken(room->name, Buf, &Pos, '|');
 169
 170                         room->QRFlags = StrBufExtractNext_long(Buf, &Pos, '|');
 171                         room->floorid = StrBufExtractNext_long(Buf, &Pos, '|');
 172                         room->listorder = StrBufExtractNext_long(Buf, &Pos, '|');
 173                         room->QRFlags2 = StrBufExtractNext_long(Buf, &Pos, '|');
 174
 175                         room->RAFlags = StrBufExtractNext_long(Buf, &Pos, '|');
 176
 177 /*
 178  ACWHUT?
 179                         room->ACL = NewStrBufPlain(NULL, StrLength(Buf));
 180                         StrBufExtract_NextToken(room->ACL, Buf, &Pos, '|');
 181 */
 182
 183                         room->view = StrBufExtractNext_long(Buf, &Pos, '|');
 184                         room->defview = StrBufExtractNext_long(Buf, &Pos, '|');
 185                         room->lastchange = StrBufExtractNext_long(Buf, &Pos, '|');
 186
 187                         /* Evaluate the Server sent data for later use */
 188                         /* find out, whether we are in a sub-room */
 189                         room->nRoomNameParts = StrBufNum_tokens(room->name, '\\');
 190                         if (room->nRoomNameParts > 1)
 191                         {
 192                                 int i;
 193
 194                                 Pos = NULL;
 195                                 room->RoomNameParts = malloc(sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 196                                 memset(room->RoomNameParts, 0, sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 197                                 for (i=0; i < room->nRoomNameParts; i++)
 198                                 {
 199                                         room->RoomNameParts[i] = NewStrBuf();
 200                                         StrBufExtract_NextToken(room->RoomNameParts[i],
 201                                                                 room->name, &Pos, '\\');
 202                                 }
 203                         }
 204
 205                         /* Private mailboxes on the main floor get remapped to the personal folder */
 206                         if ((room->QRFlags & QR_MAILBOX) &&
 207                             (room->floorid == 0))
 208                                 room->floorid = VIRTUAL_MY_FLOOR;
 209                         /* get a pointer to the floor we're on: */
 210                         GetHash(WCC->Floors, IKEY(room->floorid), &vFloor);
 211                         room->Floor = (const floor*) vFloor;
 212
 213
 214
 215                         /* now we know everything, remember it... */
 216                         Put(rooms, SKEY(room->name), room, DeleteFolder);
 217                 }
 218         }
 219 ///     SortByHashKey(rooms, 1);
 220
 221         SubTP.Filter.ContextType = CTX_ROOMS;
 222         SortIt = RetrieveSort(&SubTP, NULL, 0, HKEY("fileunsorted"), 0);
 223         if (SortIt != NULL)
 224                 SortByPayload(rooms, SortIt);
 225         else
 226                 SortByPayload(rooms, SortRoomsByListOrder);
 227         FreeStrBuf(&Buf);
 228         return rooms;
 229 }
 230
 231 /** Unused function that orders rooms by the listorder flag */
 232 int SortRoomsByListOrder(const void *room1, const void *room2)
 233 {
 234         folder *r1 = (folder*) GetSearchPayload(room1);
 235         folder *r2 = (folder*) GetSearchPayload(room2);
 236
 237         if (r1->listorder == r2->listorder) return 0;
 238         if (r1->listorder > r2->listorder) return 1;
 239         return -1;
 240 }
 241
 242 int CompareRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 243 {
 244         folder *r1 = (folder*) GetSearchPayload(room1);
 245         folder *r2 = (folder*) GetSearchPayload(room2);
 246
 247         if ((r1->Floor == NULL)  ||
 248             (r2->Floor == NULL))
 249                 return 0;
 250
 251         /**
 252          * are we on the same floor? else sort by floor.
 253          */
 254         if (r1->Floor != r2->Floor)
 255         {
 256                 /**
 257                  * the private rooms are first in any case.
 258                  */
 259                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 260                         return -1;
 261                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 262                         return 1;
 263                 /**
 264                  * else decide alpaheticaly by floorname
 265                  */
 266                 return (r1->Floor->AlphaN > r2->Floor->AlphaN)? 1 : -1;
 267         }
 268
 269         /**
 270          * if we have different levels of subdirectories,
 271          * we want the toplevel to be first, regardless of sort
 272          * sequence.
 273          */
 274         if (((r1->nRoomNameParts > 1) ||
 275             (r2->nRoomNameParts > 1)    )&&
 276             (r1->nRoomNameParts != r2->nRoomNameParts))
 277         {
 278                 int i, ret;
 279                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 280                         r2->nRoomNameParts : r1->nRoomNameParts;
 281
 282                 for (i=0; i < nparts; i++)
 283                 {
 284                         ret = strcmp (ChrPtr(r1->name),
 285                                       ChrPtr(r2->name));
 286                         /**
 287                          * Deltas in common parts? exit here.
 288                          */
 289                         if (ret != 0)
 290                                 return ret;
 291                 }
 292
 293                 /**
 294                  * who's a subdirectory of whom?
 295                  */
 296                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 297                         return 1;
 298                 else
 299                         return -1;
 300
 301         }
 302
 303         /**
 304          * else just sort alphabeticaly.
 305          */
 306         return strcmp (ChrPtr(r1->name),
 307                        ChrPtr(r2->name));
 308 }
 309
 310 int CompareRoomListByFloorRoomPrivFirstRev(const void *room1, const void *room2)
 311 {
 312         folder *r1 = (folder*) GetSearchPayload(room1);
 313         folder *r2 = (folder*) GetSearchPayload(room2);
 314
 315         if ((r1->Floor == NULL)  ||
 316             (r2->Floor == NULL))
 317                 return 0;
 318
 319         /**
 320          * are we on the same floor? else sort by floor.
 321          */
 322         if (r2->Floor != r1->Floor)
 323         {
 324                 /**
 325                  * the private rooms are first in any case.
 326                  */
 327                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 328                         return -1;
 329                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 330                         return 1;
 331                 /**
 332                  * else decide alpaheticaly by floorname
 333                  */
 334
 335                 return (r1->Floor->AlphaN < r2->Floor->AlphaN)? 1 : -1;
 336         }
 337
 338         /**
 339          * if we have different levels of subdirectories,
 340          * we want the toplevel to be first, regardless of sort
 341          * sequence.
 342          */
 343         if (((r1->nRoomNameParts > 1) ||
 344             (r2->nRoomNameParts > 1)    )&&
 345             (r1->nRoomNameParts != r2->nRoomNameParts))
 346         {
 347                 int i, ret;
 348                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 349                         r2->nRoomNameParts : r1->nRoomNameParts;
 350
 351                 for (i=0; i < nparts; i++)
 352                 {
 353                         /**
 354                          * special cases if one room is top-level...
 355                          */
 356                         if (r2->nRoomNameParts == 1)
 357                                 ret = strcmp (ChrPtr(r2->name),
 358                                               ChrPtr(r1->RoomNameParts[i]));
 359                         else if (r1->nRoomNameParts == 1)
 360                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 361                                               ChrPtr(r1->name));
 362                         else
 363                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 364                                               ChrPtr(r1->RoomNameParts[i]));
 365                         /**
 366                          * Deltas in common parts? exit here.
 367                          */
 368                         if (ret != 0)
 369                                 return ret;
 370                 }
 371
 372                 /**
 373                  * who's a subdirectory of whom?
 374                  */
 375                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 376                         return 1;
 377                 else
 378                         return -1;
 379         }
 380
 381         return strcmp (ChrPtr(r2->name),
 382                        ChrPtr(r1->name));
 383 }
 384
 385 int GroupchangeRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 386 {
 387         folder *r1 = (folder*) room1;
 388         folder *r2 = (folder*) room2;
 389
 390
 391         if ((r1->Floor == NULL)  ||
 392             (r2->Floor == NULL))
 393                 return 0;
 394
 395         if (r1->Floor == r2->Floor)
 396                 return 0;
 397         else
 398         {
 399                 wcsession *WCC = WC;
 400                 static int columns = 3;
 401                 int boxes_per_column = 0;
 402                 int nf;
 403
 404                 nf = GetCount(WCC->Floors);
 405                 while (nf % columns != 0) ++nf;
 406                 boxes_per_column = (nf / columns);
 407                 if (boxes_per_column < 1)
 408                         boxes_per_column = 1;
 409                 if (r1->Floor->AlphaN % boxes_per_column == 0)
 410                         return 2;
 411                 else
 412                         return 1;
 413 ///                                     wprintf("</td><td valign=top>\n");
 414         }
 415 }
 416
 417
 418
 419
 420
 421
 422 void tmplput_ROOM_NAME(StrBuf *Target, WCTemplputParams *TP)
 423 {
 424         folder *Folder = (folder *)(TP->Context);
 425
 426         StrBufAppendTemplate(Target, TP, Folder->name, 0);
 427 }
 428 void tmplput_ROOM_BASENAME(StrBuf *Target, WCTemplputParams *TP)
 429 {
 430         folder *room = (folder *)(TP->Context);
 431
 432         if (room->nRoomNameParts > 1)
 433                 StrBufAppendTemplate(Target, TP,
 434                                       room->RoomNameParts[room->nRoomNameParts - 1], 0);
 435         else
 436                 StrBufAppendTemplate(Target, TP, room->name, 0);
 437 }
 438 void tmplput_ROOM_LEVEL_N_TIMES(StrBuf *Target, WCTemplputParams *TP)
 439 {
 440         folder *room = (folder *)(TP->Context);
 441         int i;
 442         const char *AppendMe;
 443         long AppendMeLen;
 444
 445
 446         if (room->nRoomNameParts > 1)
 447         {
 448                 GetTemplateTokenString(Target, TP, 0, &AppendMe, &AppendMeLen);
 449                 for (i = 0; i < room->nRoomNameParts; i++)
 450                         StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0);
 451         }
 452 }
 453
 454 void tmplput_ROOM_ACL(StrBuf *Target, WCTemplputParams *TP)
 455 {
 456         folder *Folder = (folder *)(TP->Context);
 457
 458         StrBufAppendPrintf(Target, "%ld", Folder->RAFlags, 0);
 459 }
 460
 461
 462 void tmplput_ROOM_QRFLAGS(StrBuf *Target, WCTemplputParams *TP)
 463 {
 464         folder *Folder = (folder *)(TP->Context);
 465         StrBufAppendPrintf(Target, "%d", Folder->QRFlags);
 466 }
 467
 468
 469
 470 void tmplput_ROOM_FLOORID(StrBuf *Target, WCTemplputParams *TP)
 471 {
 472         folder *Folder = (folder *)(TP->Context);
 473         StrBufAppendPrintf(Target, "%d", Folder->floorid);
 474 }
 475
 476 void tmplput_ROOM_LISTORDER(StrBuf *Target, WCTemplputParams *TP)
 477 {
 478         folder *Folder = (folder *)(TP->Context);
 479         StrBufAppendPrintf(Target, "%d", Folder->listorder);
 480 }
 481 void tmplput_ROOM_VIEW(StrBuf *Target, WCTemplputParams *TP)
 482 {
 483         folder *Folder = (folder *)(TP->Context);
 484         StrBufAppendPrintf(Target, "%d", Folder->view);
 485 }
 486 void tmplput_ROOM_DEFVIEW(StrBuf *Target, WCTemplputParams *TP)
 487 {
 488         folder *Folder = (folder *)(TP->Context);
 489         StrBufAppendPrintf(Target, "%d", Folder->defview);
 490 }
 491 void tmplput_ROOM_LASTCHANGE(StrBuf *Target, WCTemplputParams *TP)
 492 {
 493         folder *Folder = (folder *)(TP->Context);
 494         StrBufAppendPrintf(Target, "%d", Folder->lastchange);
 495 }
 496 void tmplput_ROOM_FLOOR_ID(StrBuf *Target, WCTemplputParams *TP)
 497 {
 498         folder *Folder = (folder *)(TP->Context);
 499         const floor *Floor = Folder->Floor;
 500
 501         if (Floor == NULL)
 502                 return;
 503
 504         StrBufAppendPrintf(Target, "%d", Floor->ID);
 505 }
 506
 507 void tmplput_ROOM_FLOOR_NAME(StrBuf *Target, WCTemplputParams *TP)
 508 {
 509         folder *Folder = (folder *)(TP->Context);
 510         const floor *Floor = Folder->Floor;
 511
 512         if (Floor == NULL)
 513                 return;
 514
 515         StrBufAppendTemplate(Target, TP, Floor->Name, 0);
 516 }
 517
 518 void tmplput_ROOM_FLOOR_NROOMS(StrBuf *Target, WCTemplputParams *TP)
 519 {
 520         folder *Folder = (folder *)(TP->Context);
 521         const floor *Floor = Folder->Floor;
 522
 523         if (Floor == NULL)
 524                 return;
 525         StrBufAppendPrintf(Target, "%d", Floor->NRooms);
 526 }
 527
 528
 529
 530 int ConditionalRoomHas_UA_KNOWN(StrBuf *Target, WCTemplputParams *TP)
 531 {
 532         folder *Folder = (folder *)(TP->Context);
 533         return (Folder->RAFlags & UA_KNOWN) != 0;
 534 }
 535
 536 int ConditionalRoomHas_UA_GOTOALLOWED(StrBuf *Target, WCTemplputParams *TP)
 537 {
 538         folder *Folder = (folder *)(TP->Context);
 539         return (Folder->RAFlags & UA_GOTOALLOWED) != 0;
 540 }
 541
 542 int ConditionalRoomHas_UA_HASNEWMSGS(StrBuf *Target, WCTemplputParams *TP)
 543 {
 544         folder *Folder = (folder *)(TP->Context);
 545         return (Folder->RAFlags & UA_HASNEWMSGS) != 0;
 546 }
 547
 548 int ConditionalRoomHas_UA_ZAPPED(StrBuf *Target, WCTemplputParams *TP)
 549 {
 550         folder *Folder = (folder *)(TP->Context);
 551         return (Folder->RAFlags & UA_ZAPPED) != 0;
 552 }
 553
 554
 555 void jsonRoomFlr(void)
 556 {
 557         /* Send as our own (application/json) content type */
 558         hprintf("HTTP/1.1 200 OK\r\n");
 559         hprintf("Content-type: application/json; charset=utf-8\r\n");
 560         hprintf("Server: %s / %s\r\n", PACKAGE_STRING, ChrPtr(WC->serv_info->serv_software));
 561         hprintf("Connection: close\r\n");
 562         hprintf("Pragma: no-cache\r\nCache-Control: no-store\r\nExpires:-1\r\n");
 563         begin_burst();
 564         DoTemplate(HKEY("json_roomflr"),NULL,&NoCtx);
 565         end_burst();
 566 }
 567
 568
 569
 570 void
 571 InitModule_ROOMLIST
 572 (void)
 573 {
 574         WebcitAddUrlHandler(HKEY("json_roomflr"), jsonRoomFlr, 0);
 575
 576
 577         RegisterNamespace("FLOOR:ID", 0, 0, tmplput_FLOOR_ID, CTX_FLOORS);
 578         RegisterNamespace("FLOOR:NAME", 0, 1, tmplput_FLOOR_NAME, CTX_FLOORS);
 579         RegisterNamespace("FLOOR:NROOMS", 0, 0, tmplput_FLOOR_NROOMS, CTX_FLOORS);
 580
 581
 582
 583         RegisterIterator("LKRA", 0, NULL, GetRoomListHashLKRA, NULL, DeleteHash, CTX_ROOMS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 584
 585         RegisterNamespace("ROOM:INFO:FLOORID", 0, 1, tmplput_ROOM_FLOORID, CTX_ROOMS);
 586         RegisterNamespace("ROOM:INFO:NAME", 0, 1, tmplput_ROOM_NAME, CTX_ROOMS);
 587         RegisterNamespace("ROOM:INFO:BASENAME", 0, 1, tmplput_ROOM_BASENAME, CTX_ROOMS);
 588         RegisterNamespace("ROOM:INFO:LEVELNTIMES", 1, 2, tmplput_ROOM_LEVEL_N_TIMES, CTX_ROOMS);
 589
 590         RegisterNamespace("ROOM:INFO:ACL", 0, 1, tmplput_ROOM_ACL, CTX_ROOMS);
 591         RegisterNamespace("ROOM:INFO:QRFLAGS", 0, 1, tmplput_ROOM_QRFLAGS, CTX_ROOMS);
 592         RegisterNamespace("ROOM:INFO:LISTORDER", 0, 1, tmplput_ROOM_LISTORDER, CTX_ROOMS);
 593         RegisterNamespace("ROOM:INFO:VIEW", 0, 1, tmplput_ROOM_VIEW, CTX_ROOMS);
 594         RegisterNamespace("ROOM:INFO:DEFVIEW", 0, 1, tmplput_ROOM_DEFVIEW, CTX_ROOMS);
 595         RegisterNamespace("ROOM:INFO:LASTCHANGE", 0, 1, tmplput_ROOM_LASTCHANGE, CTX_ROOMS);
 596         RegisterNamespace("ROOM:INFO:FLOOR:ID", 0, 0, tmplput_ROOM_FLOOR_ID, CTX_ROOMS);
 597         RegisterNamespace("ROOM:INFO:FLOOR:NAME", 0, 1, tmplput_ROOM_FLOOR_NAME, CTX_ROOMS);
 598         RegisterNamespace("ROOM:INFO:FLOOR:NROOMS", 0, 0, tmplput_ROOM_FLOOR_NROOMS, CTX_ROOMS);
 599
 600
 601         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_KNOWN"), 0, ConditionalRoomHas_UA_KNOWN, CTX_ROOMS);
 602         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_GOTOALLOWED"), 0, ConditionalRoomHas_UA_GOTOALLOWED, CTX_ROOMS);
 603         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_HASNEWMSGS"), 0, ConditionalRoomHas_UA_HASNEWMSGS, CTX_ROOMS);
 604         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_ZAPPED"), 0, ConditionalRoomHas_UA_ZAPPED, CTX_ROOMS);
 605
 606
 607
 608         RegisterSortFunc(HKEY("byfloorroom"),
 609                          NULL, 0,
 610                          CompareRoomListByFloorRoomPrivFirst,
 611                          CompareRoomListByFloorRoomPrivFirstRev,
 612                          GroupchangeRoomListByFloorRoomPrivFirst,
 613                          CTX_ROOMS);
 614
 615 }