Changeset f74371 in indico

Timestamp:

11/08/10 15:47:59 (3 years ago)

Author:

Jose Benito <jose.benito.gonzalez@…>

Branches:

master, burotel, hello-world-walkthrough, ipv6, v0.98-series, v0.98.2, v0.98.3, v0.98b1, v0.98b2, v0.99, 051b2622c51afb171a1dedb46a0df4fbb0cbd02e, 4c7d4152dff271ba5df5a8606605969cab454080

Children:

8968bb

Parents:

6b1cbe

git-author:

Nikolche Mihajlovski <nmihajlo@…> (08/17/10 19:58:33)

git-committer:

Jose Benito <jose.benito.gonzalez@…> (11/08/10 15:47:59)

Message:

[FTR] Powerful filtering mechanism on the map

Location:

indico

Files:

• MaKaC/fossils/room.py (modified) (2 diffs)
• MaKaC/plugins/RoomBooking/default/room.py (modified) (1 diff)
• MaKaC/rb_location.py (modified) (4 diffs)
• MaKaC/search/cache.py (modified) (2 diffs)
• MaKaC/services/implementation/roomBooking.py (modified) (1 diff)
• MaKaC/services/interface/rpc/handlers.py (modified) (1 diff)
• MaKaC/webinterface/pages/roomBooking.py (modified) (3 diffs)
• MaKaC/webinterface/rh/roomBooking.py (modified) (3 diffs)
• MaKaC/webinterface/tpls/RoomBookingAdminLocation.tpl (modified) (2 diffs)
• MaKaC/webinterface/tpls/RoomBookingMapOfRooms.tpl (modified) (1 diff)
• MaKaC/webinterface/tpls/RoomBookingMapOfRoomsWidget.tpl (added)
• MaKaC/webinterface/urlHandlers.py (modified) (1 diff)
• MaKaC/webinterface/wcomponents.py (modified) (1 diff)
• htdocs/css/Default.css (modified) (1 diff)
• htdocs/css/mapofrooms.css (modified) (4 diffs)
• htdocs/js/indico/Management/Loader.js (modified) (1 diff)
• htdocs/js/indico/Management/RoomBookingMapOfRooms.js (added)
• htdocs/js/indico/RoomBooking/MapOfRooms.js (modified) (6 diffs)
• htdocs/roomBooking.py (modified) (1 diff)

indico/MaKaC/fossils/room.py

@@ -47 +47 @@
         """ ID of the responsible person for the room """
 
+    def getTipPhotoURL(self):
+        """ URL of the tip photo of the room """
+
     def isActive(self):
         """ Is the room active? """
@@ -61 +64 @@
     def getMarkerDescription(self):
         """ Room description for the map marker """
+
+    def needsAVCSetup(self):
+        """ Setup for for audio and video conference """
+
+    def getAvailableVC(self):
+        """ Available equipment for audio and video conference """

indico/MaKaC/plugins/RoomBooking/default/room.py

@@ -413 +413 @@
         """ Room URL """
         return str(urlHandlers.UHRoomBookingRoomDetails.getURL(target=self))
-        #return 'http://indico.cern.ch/roomBooking.py/roomDetails?roomLocation=CERN&roomID=3'
 
     def getMarkerDescription(self):
         """ Room description for the map marker """
-        return _("Capacity") + ": %s " % self.capacity + _("people")
+        infos = []
+        if self.capacity:
+            infos.append("%s %s" % (self.capacity , _("people")))
+        if self.isReservable:
+            infos.append(_("public"))
+        else:
+            infos.append(_("private"))
+        if self.resvsNeedConfirmation:
+            infos.append(_("needs confirmation"))
+        else:
+            infos.append(_("auto-confirmation"))
+        if self.needsAVCSetup:
+            infos.append(_("video conference"))
+        return ", ".join(infos)
+
+    def getTipPhotoURL(self):
+        """ URL of the tip photo of the room """
+        from MaKaC.webinterface.urlHandlers import UHRoomPhoto
+        return str(UHRoomPhoto.getURL(self._doGetPhotoId(force=True)))
 
     def getIsAutoConfirm(self):

indico/MaKaC/rb_location.py

@@ -47 +47 @@
         root[_ROOM_BOOKING_LOCATION_LIST] = [ ]
 
+def mapper(src, dest, properties):
+    if isinstance(src, dict) and not isinstance(dest, dict):
+        # map from dictionary keys to object attributes
+        for prop in properties:
+            setattr(dest, prop, src.get(prop, None))
+    elif not isinstance(src, dict) and isinstance(dest, dict):
+        # map from object attributes to dictionary keys
+        for prop in properties:
+            dest[prop] = getattr(src, prop, None)
+    return dest
+
+class MapAspect(Persistent, object):
+    """
+    Map aspect is a structure of data related to a view of a Google Map of rooms.
+    The rooms that are specific to a certain location can be viewed from several aspects.
+    A map aspect can be percieved as a combination of map coordinates and zoom level.
+    """
+
+    def __str__(self):
+        s = _(""" _("Id"): """) + self.id + "\n"
+        s += _(""" _("Name"): """) + self.name + "\n"
+        return s
+
+    def __cmp__(self, second):
+        return cmp(self.id, second.id)
+
+    id = None                    # str - aspects's ID
+    name = None                  # str - aspects's name
+    defaultOnStartup = False     # bool - is this aspect the default one on start-up
+    centerLatitude = None        # str - the latitude of the aspects's perspective center
+    centerLongitude = None       # str - the longitude of the aspects's perspective center
+    zoomLevel = None             # str - the zoom level of the aspects's perspective
+    topLeftLatitude = None       # str - the latitude of the aspects's left corner
+    topLeftLongitude = None      # str - the longitude of the aspects's left corner
+    bottomRightLatitude = None   # str - the latitude of the aspects's right corner
+    bottomRightLongitude = None  # str - the longitude of the aspects's right corner
+
+    __ATTRIBUTES = ['id', 'name', 'defaultOnStartup', 'centerLatitude', 'centerLongitude', 'zoomLevel',
+                    'topLeftLatitude', 'topLeftLongitude', 'bottomRightLatitude', 'bottomRightLongitude']
+
+    def toDictionary(self):
+        return mapper(self, {}, MapAspect.__ATTRIBUTES)
+
+    def updateFromDictionary(self, aspectDict):
+        return mapper(aspectDict, self, MapAspect.__ATTRIBUTES)
 
 class Location( Persistent, object ):
@@ -84 +129 @@
         self.factory = factory
         self._avcSupportEmails = []
+        self._aspects = {}
 
     def __str__( self ):
@@ -181 +227 @@
         return factories
 
+    # Aspects management ====================================================
+
+    def addAspect(self, aspect):
+        self.aspects[aspect.id] = aspect
+        self._p_changed = 1
+
+    def removeAspect(self, aspectId):
+        del self.aspects[aspectId]
+        self._p_changed = 1
+
+    def getAspect(self, aspectId):
+        return self.aspects[aspectId]
+
+    def getAspects(self):
+        return sorted(self.aspects.values())
+
+    def _getAspects(self):
+        if getattr(self, '_aspects', None) is None:
+            self._aspects = {}
+        return self._aspects
+
+    aspects = property(_getAspects)
+
     # Properties ============================================================
 
@@ -214 +283 @@
             emailList.remove( email )
         self._avcSupportEmails = emailList
-
 
 """

indico/MaKaC/search/cache.py

@@ +1 @@
+import datetime
+import os
+import time
+
 from MaKaC.common.cache import MultiLevelCache, MultiLevelCacheEntry
 
@@ -49 +53 @@
         return False
 
+
+class MapOfRoomsCacheEntry(MultiLevelCacheEntry):
+    def __init__(self, query):
+        MultiLevelCacheEntry.__init__(self)
+        self._query = query
+
+    def getQuery(self):
+        return self._query
+
+    @classmethod
+    def create(cls, content, query):
+        entry = cls(query)
+        entry.setContent(content)
+        return entry
+
+class MapOfRoomsCache(MultiLevelCache):
+    """
+    Cache that stores the appropriate record numbers for a specific search query,
+    in order to allow users to browse map of rooms
+    """
+
+    _entryFactory = MapOfRoomsCacheEntry
+
+    def __init__(self):
+        super(MapOfRoomsCache, self).__init__('mapOfRooms')
+        self._ttl = 5
+
+    def _generateFileName(self, entry, version):
+        return '%s_%s' % (entry.getQuery(), version)
+
+    def _generatePath(self, entry):
+        return ['maps']
+
+    def isDirty(self, path, object):
+        creationTime = datetime.datetime(*time.localtime(os.path.getmtime(path))[:6])
+        return datetime.datetime.now() - creationTime > datetime.timedelta(minutes=self._ttl)

indico/MaKaC/services/implementation/roomBooking.py

@@ -215 +215 @@
 
         return _( "Warning: holidays chosen" )
+
+class RoomBookingMapBase( ServiceBase ):
+    def _param(self, parameterName):
+        try:
+            return self._params[parameterName]
+        except:
+            from MaKaC.services.interface.rpc.common import ServiceError
+            raise ServiceError("ERR-RB0", "Invalid %s." % parameterName)
+
+class RoomBookingMapCreateAspect(RoomBookingMapBase):
+
+    def _checkParams( self ):
+        self._location = Location.parse(self._param("location"))
+        self._aspect = self._param("aspect")
+
+    def _getAnswer( self ):
+        aspect = MapAspect()
+        aspect.updateFromDictionary(self._aspect)
+        self._location.addAspect(aspect)
+        return {}
+
+class RoomBookingMapUpdateAspect(RoomBookingMapBase):
+
+    def _checkParams( self ):
+        self._location = Location.parse(self._param("location"))
+        self._aspect = self._param("aspect")
+
+    def _getAnswer( self ):
+        aspect = self._location.getAspect(self._aspect['id'])
+        aspect.updateFromDictionary(self._aspect)
+        return {}
+
+class RoomBookingMapRemoveAspect(RoomBookingMapBase):
+
+    def _checkParams( self ):
+        self._location = Location.parse(self._param("location"))
+        self._aspectId = self._param("aspectId")
+
+    def _getAnswer( self ):
+        self._location.removeAspect(self._aspectId)
+        return {}
+
+class RoomBookingMapListAspects(RoomBookingMapBase):
+
+    def _checkParams( self ):
+        self._location = Location.parse(self._param("location"))
+
+    def _getAnswer( self ):
+        return [aspect.toDictionary() for aspect in self._location.getAspects()]
+

indico/MaKaC/services/interface/rpc/handlers.py

@@ -21 +21 @@
     "roomBooking.locationsAndRooms.list" :roomBooking.RoomBookingListLocationsAndRooms,
     "roomBooking.getDateWarning" :roomBooking.GetDateWarning,
+
+    "roomBooking.mapaspects.create": roomBooking.RoomBookingMapCreateAspect,
+    "roomBooking.mapaspects.update": roomBooking.RoomBookingMapUpdateAspect,
+    "roomBooking.mapaspects.remove": roomBooking.RoomBookingMapRemoveAspect,
+    "roomBooking.mapaspects.list": roomBooking.RoomBookingMapListAspects,
 
     "resources.timezones.getAll": resources.GetTimezones,

indico/MaKaC/webinterface/pages/roomBooking.py

@@ -23 +23 @@
 import MaKaC.webinterface.wcomponents as wcomponents
 from MaKaC.webinterface.pages.main import WPMainBase
+from MaKaC.webinterface.pages.base import WPNotDecorated
 from MaKaC.rb_location import CrossLocationDB
 import MaKaC.common.info as info
@@ -223 +224 @@
 class WPRoomBookingMapOfRooms(WPRoomBookingBase):
 
-    def __init__(self, rh):
-        WPRoomBookingBase.__init__(self, rh)
-        self._rh = rh
-        self.addExtraCSSFile('mapofrooms.css')
-
-    def getJSFiles(self):
-        return WPRoomBookingBase.getJSFiles(self) + \
-               self._includeJSPackage('RoomBooking')
-
     def _getTitle(self):
         return WPRoomBookingBase._getTitle(self) + " - " + _("Map of rooms")
@@ -239 +231 @@
 
     def _getBody(self, params):
-        wc = wcomponents.WRoomBookingMapOfRooms(self._rh)
+        wc = wcomponents.WRoomBookingMapOfRooms()
+        return wc.getHTML(params)
+
+class WPRoomBookingMapOfRoomsWidget(WPNotDecorated):
+
+    def __init__(self, rh, aspects, buildings, defaultLocation, forVideoConference):
+        WPNotDecorated.__init__(self, rh)
+        self._aspects = aspects
+        self._buildings = buildings
+        self._defaultLocation = defaultLocation
+        self._forVideoConference = forVideoConference
+        self.addExtraCSSFile('mapofrooms.css')
+
+    def getJSFiles(self):
+        return WPNotDecorated.getJSFiles(self) + \
+               self._includeJSPackage('RoomBooking')
+
+    def _getTitle(self):
+        return WPNotDecorated._getTitle(self) + " - " + _("Map of rooms")
+
+    def _setCurrentMenuItem(self):
+        self._roomMapOpt.setActive(True)
+
+    def _getBody(self, params):
+        wc = wcomponents.WRoomBookingMapOfRoomsWidget(self._aspects, self._buildings, self._defaultLocation, self._forVideoConference)
         return wc.getHTML(params)
 

indico/MaKaC/webinterface/rh/roomBooking.py

@@ -45 +45 @@
 from MaKaC import plugins
 from MaKaC.plugins.RoomBooking.default.reservation import ResvHistoryEntry
+from MaKaC.search.cache import MapOfRoomsCache
 
 class CandidateDataFrom( object ):
@@ -669 +670 @@
 class RHRoomBookingMapOfRooms(RHRoomBookingBase):
 
-    def _businessLogic( self ):
+    def _process(self):
+        page = roomBooking_wp.WPRoomBookingMapOfRooms(self)
+        return page.display()
+
+class RHRoomBookingMapOfRoomsWidget(RHRoomBookingBase):
+
+    def __init__(self, *args, **kwargs):
+        super(RHRoomBookingMapOfRoomsWidget, self).__init__(*args, **kwargs)
+        self._cache = MapOfRoomsCache()
+
+    def _checkParams(self, params):
+        RHRoomBookingBase._checkParams(self, params)
+
+    def _businessLogic(self):
         # get all rooms
-        rooms = RoomBase.getRooms(allFast=True)
+        defaultLocation = Location.getDefaultLocation()
+        rooms = RoomBase.getRooms(location=defaultLocation.friendlyName)
+        aspects = [aspect.toDictionary() for aspect in defaultLocation.getAspects()]
+
+        # specialization for a video conference, CERN-specific
+        possibleEquipment = defaultLocation.factory.getEquipmentManager().getPossibleEquipment()
+        possibleVideoConference = 'Video conference' in possibleEquipment
+        self._forVideoConference = possibleVideoConference and self._getRequestParams().get("avc") == 'y'
 
         # break-down the rooms by buildings
@@ -692 +713 @@
 
                 # add the room to its building
-                building['rooms'].append(room.fossilize())
-
-        # filter the buildings with coordinates and return them
-        buildings_with_coords = [b for b in buildings.values() if b['has_coordinates']]
+                if not self._forVideoConference or room.needsAVCSetup:
+                    building['rooms'].append(room.fossilize())
+
+        # filter the buildings with rooms and coordinates and return them
+        buildings_with_coords = [b for b in buildings.values() if b['rooms'] and b['has_coordinates']]
+        self._defaultLocation = defaultLocation.friendlyName
+        self._aspects = aspects
         self._buildings = buildings_with_coords
 
     def _process(self):
         self._businessLogic()
-        p = roomBooking_wp.WPRoomBookingMapOfRooms(self)
-        return p.display()
+        page = roomBooking_wp.WPRoomBookingMapOfRoomsWidget(self, self._aspects, self._buildings, self._defaultLocation, self._forVideoConference)
+
+        params = self._getRequestParams()
+        entry = self._cache.loadObject('', params)
+        if entry:
+            html = entry.getContent()
+        else:
+            html = page.display()
+            self._cache.cacheObject('', html, params)
+        return html
 
 # 2. List of ...

indico/MaKaC/webinterface/tpls/RoomBookingAdminLocation.tpl

@@ -139 +139 @@
       </td>
     </tr>
+
+    <tr><td>&nbsp;</td></tr>
+    <tr>
+      <td class="titleUpCellTD" style="width: 160px;"><span class="titleCellFormat">Room map attributes</span></td>
+      <td bgcolor="white" valign="top" class="blacktext" style="padding-left: 12px;">
+        <div id="AspectsListHolder"></div>
+      </td>
+    </tr>
+
     </table>
     <br>
 
+<script type="text/javascript">
+
+var newAspectsHandler = function(newAspect, setResult) {
+    indicoRequest(
+        'roomBooking.mapaspects.create',
+        {
+            location: '<%=location.friendlyName%>',
+            aspect: newAspect
+        },
+        function(result,error) {
+            if (!error) {
+                setResult(true);
+            } else {
+                IndicoUtil.errorReport(error);
+                setResult(false);
+            }
+        }
+    );
+}
+
+var editAspectHandler = function(oldAspect, setResult, newAspect) {
+    indicoRequest(
+        'roomBooking.mapaspects.update',
+        {
+            location: '<%=location.friendlyName%>',
+            aspect: newAspect
+        },
+        function(result,error) {
+            if (!error) {
+                setResult(true);
+            } else {
+                IndicoUtil.errorReport(error);
+                setResult(false);
+            }
+        }
+    );
+}
+
+var removeAspectHandler = function(aspect, setResult) {
+    indicoRequest(
+        'roomBooking.mapaspects.remove',
+        {
+            location: '<%=location.friendlyName%>',
+            aspectId: aspect.get('id')
+        },
+        function(result,error) {
+            if (!error) {
+                setResult(true);
+            } else {
+                IndicoUtil.errorReport(error);
+                setResult(false);
+            }
+        }
+    );
+}
+    indicoRequest(
+        'roomBooking.mapaspects.list',
+        {
+            location: '<%= location.friendlyName %>'
+        },
+        function(result,error) {
+            if (!error) {
+                var aspectsListField = new MapAspectListField('AspectsListDiv', 'PeopleList', result,
+                        newAspectsHandler, editAspectHandler, removeAspectHandler);
+                $E('AspectsListHolder').set(aspectsListField.draw());
+            } else {
+                IndicoUtil.errorReport(error);
+            }
+        }
+    );
+
+</script>
 
 <!-- ============== Key Performance Indicators ================= -->
@@ -238 +319 @@
 </tr>
 </table>
+

indico/MaKaC/webinterface/tpls/RoomBookingMapOfRooms.tpl

@@ -1 @@
-<table id="map_table">
-    <tr>
-        <td id="map_table_left">
-            <div id="positions_canvas"></div>
-            <div id="map_canvas"></div>
-        </td>
-        <td id="map_table_right">
-            <div id="filter_canvas"></div>
-        </td>
-    </tr>
-</table>
-
-<script type="text/javascript">
-
-var positions = [
-    {'lat':46.23456689405093, 'lon':6.046686172485352, 'zoom':15, 'name':'Meyrin', 'isDefault':true},
-    {'lat':46.259051447415175, 'lon':6.057773351931246, 'zoom':15, 'name':'PREVESSIN'},
-    {'lat':46.23573201283012, 'lon':6.054509639707248, 'zoom':17, 'name':'POINT 1'},
-    {'lat':46.25115822762375, 'lon':6.020456314054172, 'zoom':17, 'name':'POINT 2'},
-    {'lat':46.30958858268458, 'lon':6.077267646724067, 'zoom':17, 'name':'POINT 5'},
-    {'lat':46.29345231426436, 'lon':6.1115119456917455, 'zoom':17, 'name':'POINT 6'},
-    {'lat':46.24158691675184, 'lon':6.097038745847385, 'zoom':17, 'name':'POINT 8'}
-];
-var buildings = <%= jsonEncode(buildings) %>;
-
-IndicoUI.executeOnLoad(function(){
-    var roomMap = new RoomMap($E('map_canvas').dom, $E('positions_canvas').dom, positions, buildings);
-});
-
-</script>
+<iframe src="<%= mapOfRoomsWidgetURL %>"
+    frameborder="0"
+    width="100%%"
+    height="600px"
+    style="margin-top: -10px;">
+</iframe>

indico/MaKaC/webinterface/urlHandlers.py

@@ -302 +302 @@
 class UHRoomBookingMapOfRooms( URLHandler ):
     _relativeURL = "roomBooking.py/mapOfRooms"
+
+class UHRoomBookingMapOfRoomsWidget( URLHandler ):
+    _relativeURL = "roomBooking.py/mapOfRoomsWidget"
 
 class UHRoomBookingWelcome( URLHandler ):

indico/MaKaC/webinterface/wcomponents.py

@@ -6120 +6120 @@
 class WRoomBookingMapOfRooms(WTemplated):
 
-    def __init__(self, rh):
-        self._rh = rh
+    def getVars(self):
+
+        vars = WTemplated.getVars(self)
+        vars["mapOfRoomsWidgetURL"] = urlHandlers.UHRoomBookingMapOfRoomsWidget.getURL( None )
+
+        return vars
+
+class WRoomBookingMapOfRoomsWidget(WTemplated):
+
+    def __init__(self, aspects, buildings, defaultLocation, forVideoConference):
+        self._aspects = aspects
+        self._buildings = buildings
+        self._defaultLocation = defaultLocation
+        self._forVideoConference = forVideoConference
 
     def getVars(self):
         vars = WTemplated.getVars(self)
 
-        vars["buildings"] = self._rh._buildings
+        vars["aspects"] = self._aspects
+        vars["buildings"] = self._buildings
+        vars["defaultLocation"] = self._defaultLocation
+        vars["forVideoConference"] = self._forVideoConference
 
         return vars

indico/htdocs/css/Default.css

@@ -5720 +5720 @@
 }
 
+div.AspectsListDiv {
+    margin-bottom: 10px;
+    height: 100px;
+    width: 350px;
+    border: 1px solid #CCCCCC;
+    overflow: auto;
+}
+
 div.PeopleListDiv {
     margin-bottom: 10px;

indico/htdocs/css/mapofrooms.css

@@ +1 @@
+.tip p {
+    margin-top: 8px;
+    margin-bottom: 8px;
+}
+
+div.caption {
+    padding: 3px;
+    background-color: #F0F0F0 !important;
+    border: 1px solid #888888;
+    border-bottom: none;
+}
+
 /* Marker info */
+
+.mapBuildingInfo {
+    max-height: 300px;
+    overflow-y: auto;
+}
+
+.mapRoomInfoLink {
+    border-left: 1px solid #AAAAAA;
+    padding-left: 5px;
+}
+
+.mapBookRoomLink {
+    padding-right: 5px;
+}
 
 #filter_canvas {
     width: 200px;
+    padding-left: 10px;
+}
+
+.mapFilterTitle {
+    color: #777777;
+    font-size: 15px;
+    margin: 0;
+    padding: 0;
+    font-weight: bold;
+}
+
+.mapFilterGroup {
+    padding-left: 20px;
+}
+
+.mapFilterTextbox {
+    width: 70px;
+}
+
+.mapFilterLabel {
+    color:#444444;
+    font-size:13px;
+    padding-right: 5px;
+    padding-left: 2px;
+    display: inline-block;
+    min-width: 70px;
+}
+
+.mapRoomTooltipTitle {
+    font-weight: bold;
+    padding-left: 3px;
+}
+
+.mapRoomTooltipImage {
+    padding-left: 8px;
+    padding-right: 8px;
+}
+
+.mapRoomTooltipDescription {
+    padding-left: 8px;
+    padding-right: 8px;
+}
+
+.mapResultsInfo {
+    font-weight: bold;
+    font-size: 12px;
+}
+
+#mapFilterBox {
+    float: none;
+    margin-top: -27px;
+    margin-left: 10px;
+    width: 210px;
+}
+
+#mapFilterContentBox {
+    padding-right: 10px;
+    padding-left: 5px;
+}
+
+#filter_canvas {
+    margin-top: -3px;
+}
+
+#filter_canvas p {
+    margin-top: 10px;
+    margin-bottom: 10px;
+}
+.mapBuildingTitle {
+    font-weight: bold;
+}
+
+.mapButton {
+    margin-right: 5px;
+}
+
+/* Map table */
+
+html, body {
+    margin: 0 auto;
+    height: 100%;
+}
+
+#map_table {
+    width: 99%;
+    height: 90%;
+}
+
+#map_cell {
+    width: 100%;
+    height:100%;
+}
+
+#map_canvas {
+    width: 100%;
+    height:100%;
 }
 
@@ -11 +133 @@
 #map_table_left {
     width: 100%;
-}
-
-#map_canvas {
-    width: 100%;
-    height: 600px;
-}
-
-#map_table {
-    width: 100%;
-}
-
-.mapBuildingTitle {
-    font-weight: bold;
 }
 
@@ -37 +146 @@
 
 ul.mapAspectsList li {
+    position: relative;
+    padding-right: 5px;
+    padding-left: 5px;
+    border-right: 1px solid #AAAAAA;
+}
+
+ul.mapAspectsList li.browserIE7 {
     display: inline;
-    position: relative;
-    padding-right: 15px;
-    padding-left: 15px;
-    border-right: 1px solid #AAAAAA;
+}
+
+ul.mapAspectsList li.browserDefault {
+    display: inline-table;
 }
 
 ul.mapAspectsList a {
     font-family: Verdana;
-    font-size: 16px;
+    font-size: 13px;
     font-weight: bold;
     cursor: pointer;
@@ -53 +169 @@
 ul.mapAspectsList a:hover {
     color: #dbb03a !important;
+}
+
+.mapAspectsItem {
+    white-space: nowrap;
 }
 

indico/htdocs/js/indico/Management/Loader.js

@@ -4 +4 @@
 include(ScriptRoot + "indico/Management/eventCreation.js");
 include(ScriptRoot + "indico/Management/Timetable.js");
+include(ScriptRoot + "indico/Management/RoomBookingMapOfRooms.js");

indico/htdocs/js/indico/RoomBooking/MapOfRooms.js

@@ -1 @@
-// include the Google Maps API
-mapsKey = "ABQIAAAAma3utMfjLLhSmsMwYFxuOxQw5QZGSL2Qh09zAqNyDcYBVXi0OBTBnNqS2Hl5cVWGNuhE9BATvtEqyA";
-include("http://maps.google.com/maps?file=api&v=2&key=" + mapsKey);
+include("http://maps.google.com/maps/api/js?sensor=false");
 
 /**
@@ -8 +6 @@
 type ("RoomMap", ["IWidget"],
     {
-        initialize: function(mapCanvas, aspectsCanvas, aspects, buildings) {
-            if (GBrowserIsCompatible()) {
-                this.createMap(mapCanvas);
-                this.createAspectChangeLinks(aspectsCanvas, aspects);
-                this.createMarkers(buildings);
-            } else {
-                this.showNotCompatible(mapCanvas);
+        initialize: function(mapCanvas, aspectsCanvas, filterCanvas, aspects, buildings, filters) {
+            this.initData(aspects, buildings, filters);
+            this.createMap(mapCanvas);
+            this.initializeBounds();
+            this.createAspectChangeLinks(aspectsCanvas);
+            this.createBuildingMarkers();
+            this.createFilters(filterCanvas);
+            this.setDefaultFilterValues();
+            this.updateFiltersState();
+            this.filterMarkers();
+        },
+
+        initData: function(aspects, buildings, filters) {
+            this.aspects = aspects;
+            this.buildings = buildings;
+            this.filters = filters;
+
+            // save a reference to the building number filter
+            for (var i = 0; i < filters.length; i++) {
+                var filter = filters[i];
+                if (filter.filterType == 'building' && filter.property == 'number') {
+                    this.buildingNumberFilter = filter;
+                }
             }
         },
 
         createMap: function(mapCanvas) {
+            this.markers = [];
+
+            // map options
+            var options = {
+              zoom: 17,
+              mapTypeId: google.maps.MapTypeId.HYBRID
+            };
+
             // Google Maps API setup
-            this.map = new GMap2(mapCanvas);
-            this.map.setMapType(G_HYBRID_MAP);
-            this.map.setUIToDefault();
-            this.map.enableDoubleClickZoom();
-        },
-
-        createInfoMarker: function(point, info) {
-            var marker = new GMarker(point);
-
-            // when the marker is clicked, open the info window
-            GEvent.addListener(marker, "click", function() {
-                marker.openInfoWindowHtml(info);
-            });
-
-            return marker;
+            this.map = new google.maps.Map(mapCanvas, options);
+            google.maps.event.addListener(this.map, "click", this.createMapClickHandler());
+        },
+
+        createMapClickHandler: function() {
+            var self = this;
+            return function() {
+                self.closeTooltips();
+                self.closeInfoBaloon();
+            }
+        },
+
+        createBuildingMarkers: function() {
+            for (var i in this.buildings) {
+                var building = this.buildings[i];
+                building.point = new google.maps.LatLng(building.latitude, building.longitude);
+
+                // create marker for the building
+                var marker = new google.maps.Marker({
+                    position: building.point,
+                    map: this.map,
+                    visible: false
+                });
+
+                // the building and marker reference each-other
+                marker.building = building;
+                building.marker = marker;
+
+                // when the marker is clicked, open the info window
+                marker.onClick = this.createMarkerClickHandler(marker);
+                google.maps.event.addListener(marker, "click", marker.onClick);
+
+                this.markers.push(marker);
+            }
+        },
+
+        createMarkerClickHandler: function(marker) {
+            var self = this;
+            return function() {
+                // it the info baloon is shown for a first time, create it
+                if (!exists(marker.infoWindow)) {
+                    var info = self.createBuildingInfo(marker.building);
+                    marker.infoWindow = new google.maps.InfoWindow({content: info});
+                }
+
+                // closed the tooltips and info baloon
+                self.closeInfoBaloon();
+                self.closeTooltips();
+
+                // show the info baloon
+                self.activeInfoWindow = marker.infoWindow;
+                marker.infoWindow.open(self.map, marker);
+            }
+        },
+
+        closeInfoBaloon: function() {
+            // if a info baloon is shown, close it
+            if (exists(this.activeInfoWindow)) {
+                this.activeInfoWindow.close();
+                this.activeInfoWindow = null;
+            }
+        },
+
+        closeTooltips: function() {
+            domTT_closeAll();
         },
 
@@ -40 +112 @@
             // unselect the previous selected link (if any)
             if (this.selectedLink) {
-                this.selectedLink.dom.className = 'mapAspectUnselected';
+                this.selectedLink.dom.className = this.constructAspectCss(false);
             }
 
             // select the clicked link
             this.selectedLink = link;
-            link.dom.className = 'mapAspectSelected';
+            link.dom.className = this.constructAspectCss(true);
         },
 
         createAspectChangeFunction: function(aspect, link) {
-            setSelectedAspectStyle = this.setSelectedAspectStyle;
-            map = this.map;
+            var self = this;
+            // execute this every time the user clicks on some aspect and changes the visible map area
             return function() {
-                map.setCenter(new GLatLng(aspect.lat, aspect.lon), aspect.zoom);
-                setSelectedAspectStyle(link);
-            }
-        },
-
-        createAspectChangeLinks: function(aspectsCanvas, aspects) {
+                self.closeTooltips();
+                self.map.setCenter(new google.maps.LatLng(aspect.centerLatitude, aspect.centerLongitude));
+                self.map.setZoom(parseInt(aspect.zoomLevel));
+                self.setSelectedAspectStyle(link);
+            }
+        },
+
+        constructBrowserSpecificCss: function() {
+            return this.isBrowserIE7() ? 'browserIE7' : 'browserDefault';
+        },
+
+        constructAspectCss: function (selected) {
+            var selectionClass = selected ? 'mapAspectSelected' : 'mapAspectUnselected';
+            return 'mapAspectsItem ' + selectionClass;
+        },
+
+        createAspectChangeLinks: function(aspectsCanvas) {
             var links = Html.ul({className:'mapAspectsList'}).dom;
-            for (var i = 0; i < aspects.length; i++) {
-                aspect = aspects[i];
+            for (var i = 0; i < this.aspects.length; i++) {
+                var aspect = this.aspects[i];
 
                 // construct a link that changes the map aspect if clicked
-                var link = Html.a({'href':'#', className:'mapAspectUnselected'}, aspect.name);
-                var itemClassName = i == 0 ? 'first' : i == aspects.length - 1 ? 'last' : '';
-                var item = Html.li({className:itemClassName}, link.dom);
+                var link = Html.a({'href': '#', className: this.constructAspectCss(false)}, aspect.name);
+                var itemClassName = i == 0 ? 'first ' : i == this.aspects.length - 1 ? 'last ' : '';
+                var item = Html.li({className:itemClassName + this.constructBrowserSpecificCss()}, link.dom);
                 var aspectChangeFunction = this.createAspectChangeFunction(aspect, link);
 
+                // store the link for the aspect
+                aspect.link = link;
+
                 // if the aspect is a default one, apply it on start
-                if (aspect.isDefault) {
+                if (aspect.defaultOnStartup) {
                     aspectChangeFunction();
                 }
@@ -82 +168 @@
 
         createRoomInfo: function(building, room) {
-            // info format: [link with room address] - [description of the room]
+            var self = this;
             var address = building.number + '/' + room.floor + '-' + room.roomNr;
-            var link = Html.a({href:room.url, className:'mapRoomLink'}, address).dom;
-            var desc = Html.span({className:'mapRoomDescription'}, room.markerDescription).dom;
-
-            roomInfo = Html.p({className:'mapRoomInfo'}, link, ' - ', desc);
+            var caption = "Room " + address;
+
+            // room address
+            var addr = Html.span({className:'mapRoomAddress'}, address).dom;
+
+            // "Book" link
+            var book = Html.a({href:room.url, className:'mapBookRoomLink'}, "Book");
+
+            // "More" link - for room details
+            var more = Html.a({href:"#", className:'mapRoomInfoLink'}, "More...");
+
+            // room details elements
+            var title = Html.div({className: 'mapRoomTooltipTitle'}, caption);
+            var img = Html.img({src: room.tipPhotoURL, width: 212, height: 140, className: 'mapRoomTooltipImage'});
+            var desc = Html.div({className: 'mapRoomTooltipDescription'}, room.markerDescription);
+            var all = Widget.lines([img, desc]);
+            var help = Html.div({className: 'tip'}, all.dom);
+
+            // when the "More" link is clicked, show a tooltip with room details
+            more.observeClick(function(event) {
+                self.closeTooltips();
+                domTT_activate(more.dom, event, 'content', help.dom, 'maxWidth', 223, 'type', 'sticky', 'caption', title.dom, 'closeLink', ' x  ');
+            });
+
+            var roomInfo = Html.p({className:'mapRoomInfo'}, addr, ' - ', book.dom, more.dom);
             return roomInfo.dom;
         },
@@ -101 +208 @@
             for (var j = 0; j < building.rooms.length; j++) {
                 var room = building.rooms[j];
-                var roomInfo = this.createRoomInfo(building, room);
-                roomsInfo.appendChild(roomInfo);
-            }
-
+                if (room.showOnMap) {
+                    var roomInfo = this.createRoomInfo(building, room);
+                    roomsInfo.appendChild(roomInfo);
+                }
+            }
+
+            // building info box
             var buildingInfo = Html.div({className:'mapBuildingInfo'}, title, roomsInfo);
             return buildingInfo.dom;
         },
 
-        createMarkers: function(buildings) {
-            for (var i = 0; i < buildings.length; i++) {
-                var building = buildings[i];
-
-                // initialize the marker aspect and info
-                var pos = new GLatLng(building.latitude, building.longitude);
-                var info = this.createBuildingInfo(building);
-
-                // construct the marker and add it to the map overlay
-                var marker = this.createInfoMarker(pos, info);
-                this.map.addOverlay(marker);
-            }
-        },
-
-        showNotCompatible: function(mapCanvas) {
-            var info = Html.div({}, "Your browser is not compatible with Google Maps!").dom;
-            mapCanvas.appendChild(info);
-        },
+        showMarkers: function() {
+            var bounds = this.map.getBounds();
+            var inBoundsCount = 0;
+
+            // 'alone' building - a bulding that is displayed alone on the screen
+            var aloneBuilding = null;
+
+            // 'exact' building - a building whose number was entered in the building filter
+            var exactBuilding = null;
+
+            // if a building number filter exists, get its value
+            var exactBuildingNumber = null;
+            if (this.buildingNumberFilter) {
+                exactBuildingNumber = this.getFilterValue(this.buildingNumberFilter);
+            }
+
+            for (var i = 0; i < this.buildings.length; i++) {
+                var building = this.buildings[i];
+                this.boundCounters[i] = 0;
+
+                // if the building is filtered as visible on map
+                if (building.showOnMap) {
+                    // if only 1 building is visible - that's the 'alone' building
+                    if (this.visibleBuildingsCount == 1) {
+                        aloneBuilding = building;
+                    }
+
+                    // if the building number is entered in the building filter, that's the 'exact' building
+                    if (exactBuildingNumber != null && building.number == exactBuildingNumber) {
+                        exactBuilding = building;
+                    }
+
+                    // initialize the marker aspect and info
+                    var pos = new google.maps.LatLng(building.latitude, building.longitude);
+
+                    // count the number of rooms in each of the aspect areas
+                    for (var j = 0; j < this.bounds.length; j++) {
+                        if (this.bounds[j].contains(pos)) {
+                            this.boundCounters[j] += building.visibleRoomsSize;
+                        }
+                    }
+                }
+
+                // show only the filtered buildings
+                building.marker.setVisible(building.showOnMap);
+            }
+
+            // if an 'exact' building if found, show it in the center of the map
+            if (exactBuilding != null) {
+                var center = new google.maps.LatLng(exactBuilding.latitude, exactBuilding.longitude);
+                this.map.setCenter(center);
+            }
+
+            // if an 'alone' building if found, show its info baloon
+            if (aloneBuilding != null) {
+                aloneBuilding.marker.onClick();
+            }
+
+        },
+
+        getFilterPropertyOptions: function(filter) {
+            var options = [];
+            function addOption(option) {
+                if (options.indexOf(option) < 0) options.push(option);
+            }
+
+            for (var i = 0; i < this.buildings.length; i++) {
+                var building = this.buildings[i];
+                if (filter.filterType == 'building') {
+                    addOption(building[filter.property]);
+                } else {
+                    for (var j = 0; j < building.rooms.length; j++) {
+                        var room = building.rooms[j];
+                        addOption(room[filter.property]);
+                    }
+                }
+            }
+
+            return options;
+        },
+
+        updateFiltersState: function() {
+            for (var i = 0; i < this.filters.length; i++) {
+                var filter = this.filters[i];
+
+                // the corresponding function calculates if the filter input is enabled (default: yes)
+                filter.enabled = !exists(filter.enabledIf) || filter.enabledIf(this);
+                filter.input.dom.disabled = !filter.enabled;
+
+                // the corresponding function calculates if the filter is active (default: yes)
+                filter.active = !exists(filter.activeIf) || filter.activeIf(this);
+            }
+        },
+
+        createFilterWidget: function(filter) {
+            // value type
+            var input;
+            if (filter.inputType == 'text' || filter.inputType == 'subtext') {
+                // text input for text and sub-text filters
+                input = Html.input('text', {className: 'mapFilterTextbox'});
+            } else if (filter.inputType == 'boolean') {
+                // checkbox input for boolean filters
+                input = Html.checkbox({className: 'mapFilterCheckbox'});
+            } else if (filter.inputType == 'list_contains') {
+                // checkbox input for 'list containts' filters
+                input = Html.checkbox({className: 'mapFilterCheckbox'});
+            } else if (filter.inputType == 'hidden') {
+                // no input for hidden filters
+                input = null;
+            } else if (filter.inputType == 'combo') {
+                // drop-down box input for combo filters
+                var options = [];
+                var optionValues = this.getFilterPropertyOptions(filter);
+                for (var i = 0; i < optionValues.length; i++) {
+                    var optionValue = optionValues[i];
+                    var option = Html.option({value: optionValue}, optionValue);
+                    options.push(option);
+                }
+                input = Html.select({className: 'mapFilterCombo'}, options);
+            }
+
+            if (input) {
+                filter.input = input;
+
+                // observe change of the filter inputs
+                var self = this;
+                input.observeKeyPress(function(key) {
+                    self.onFiltersInputChanged();
+                });
+                input.observeChange(function(key) {
+                    self.onFiltersInputChanged();
+                });
+
+                // title
+                var label = Html.span({className: 'mapFilterLabel'}, filter.label);
+
+                // layout order
+                var order;
+                if (filter.inputType == 'text' || filter.inputType == 'subtext' || filter.inputType == 'combo') {
+                    order = [label, input];
+                } else {
+                    order = [input, label];
+                }
+                return Widget.inline(order);
+            } else {
+                return null;
+            }
+        },
+
+        onFiltersInputChanged: function() {
+            this.updateFiltersState();
+        },
+
+        setDefaultFilterValue: function(filter) {
+            if (filter.group !== undefined) {
+                if (filter.defaultValue !== undefined) {
+                    filter.mainCheckbox.dom.checked = filter.defaultValue;
+                    filter.mainCheckbox.dispatchEvent("change");
+                }
+                for (var i = 0; i < filter.group.length; i++) {
+                    this.setDefaultFilterValue(filter.group[i]);
+                }
+            } else {
+                if (filter.defaultValue !== undefined && filter.input) {
+                    if (filter.inputType == 'boolean' || filter.inputType == 'list_contains') {
+                        filter.input.dom.checked = filter.defaultValue;
+                    } else {
+                        filter.input.dom.value = filter.defaultValue;
+                    }
+                    filter.input.dispatchEvent("change");
+                }
+            }
+        },
+
+        setDefaultFilterValues: function() {
+            for (var i = 0; i < this.filters.length; i++) {
+                this.setDefaultFilterValue(this.filters[i]);
+            }
+        },
+
+        createGroupWidget: function(filter) {
+            var widgets = Html.div({className: "mapFilterGroup"}, this.createFilterWidgets(filter.group));
+
+            var mainCheckbox = Html.checkbox({className: 'mapFilterCheckbox'});
+
+            function onMainCheckboxClick() {
+                if (mainCheckbox.dom.checked) {
+                    IndicoUI.Effect.appear(widgets);
+                } else {
+                    IndicoUI.Effect.disappear(widgets);
+                }
+            }
+
+            mainCheckbox.observeChange(onMainCheckboxClick);
+            onMainCheckboxClick();
+
+            var label = Html.span({className: 'mapFilterLabel'}, filter.label);
+
+            var top = Html.div({}, mainCheckbox, label);
+
+            filter.widgets = widgets;
+            filter.mainCheckbox = mainCheckbox
+            return Html.div({}, top, widgets);
+        },
+
+        createFilterWidgets: function(filters) {
+            var widgets = [];
+            for (var i = 0; i < filters.length; i++) {
+                var filter = filters[i];
+                var widget;
+                if (exists(filter.group)) {
+                    widget = this.createGroupWidget(filter);
+                } else {
+                    widget = this.createFilterWidget(filter);
+                }
+                widgets.push(widget);
+            }
+            return Widget.lines(widgets);
+        },
+
+        createFilters: function(filterCanvas) {
+            var lines = [];
+
+            var title = Html.div({className: 'mapFilterTitle'}, $T("Search criteria")+":");
+            lines.push(title);
+
+            var widgets = this.createFilterWidgets(this.filters);
+            lines.push(widgets);
+
+            var self = this;
+
+            var filterButton = Html.button('mapButton', $T("Filter"));
+            filterButton.observeClick(function() {
+                self.filterMarkers();
+            });
+
+            var resetButton = Html.button('mapButton', $T("Reset"));
+            resetButton.observeClick(function() {
+                self.setDefaultFilterValues();
+                self.filterMarkers();
+            });
+
+            this.buttons = Html.div({}, filterButton, resetButton);
+            lines.push(this.buttons);
+
+            this.progress = Html.span({}, progressIndicator(true, true)).dom;
+
+            this.resultsInfo = Html.span('mapResultsInfo', "");
+            lines.push(this.resultsInfo);
+
+            filterCanvas.appendChild(Widget.lines(lines).dom);
+        },
+
+        matchesCriteria: function(x, criteria) {
+            for (var i = 0; i < criteria.length; i++) {
+                var criterium = criteria[i];
+                if (!criterium(x)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+
+        filterByCriteria: function(items, criteria) {
+            var count = 0;
+            for (var i = 0; i < items.length; i++) {
+                var item = items[i];
+                item.showOnMap = this.matchesCriteria(item, criteria);
+                if (item.showOnMap) {
+                    count++;
+                }
+            }
+            return count;
+        },
+
+        filterBuildingsByCriteria: function(buildingCriteria, roomCriteria) {
+            this.filterByCriteria(this.buildings, buildingCriteria);
+            for (var i = 0; i < this.buildings.length; i++) {
+                var building = this.buildings[i];
+                if (building.showOnMap) {
+                    building.visibleRoomsSize = this.filterByCriteria(building.rooms, roomCriteria);
+                    this.visibleRoomsCount += building.visibleRoomsSize;
+                    if (building.visibleRoomsSize > 0) {
+                        this.visibleBuildingsCount++;
+                    } else {
+                        building.showOnMap = false;
+                    }
+                } else {
+                    building.visibleRoomsSize = 0;
+                }
+            }
+        },
+
+        building: function(number) {
+            for (var i = 0; i < this.buildings.length; i++) {
+                var building = this.buildings[i];
+                if (building.number == number) {
+                    return building;
+                }
+            }
+            return null;
+        },
+
+        filterInput: function(index) {
+            return this.getFilterValue(this.filters[index]);
+        },
+
+        createPropertyFilter: function(inputType, propertyName, expectedValue) {
+            if (inputType == 'list_contains') {
+                return function(obj) {
+                    // search for element in the list
+                    return obj[propertyName].indexOf(expectedValue) > -1;
+                }
+            } else if (inputType == 'subtext') {
+                return function(obj) {
+                    // search for substring in the string
+                    return obj[propertyName].indexOf(expectedValue) > -1;
+                }
+            } else {
+                return function(obj) {
+                    return obj[propertyName] == expectedValue;
+                }
+            }
+        },
+
+        getFilterValue: function(filter) {
+            var value; // the filter value
+            if (filter.inputType == 'boolean') {
+                // boolean value that tells if checkbox is checked
+                value = filter.input.dom.checked;
+                if (value && filter.checkedValue !== undefined) {
+                    // if the checkbox is checked, the boolean value can be replaced with arbitrary one
+                    value = filter.checkedValue;
+                } else if (value && filter.filterFunction !== undefined) {
+                    // for more complex filtering logic, a custom filter function can be specified
+                    value = filter.filterFunction;
+                }
+            } else if (filter.inputType == 'list_contains') {
+                // if the checkbox is checked, the filter value is the specified one
+                value = filter.input.dom.checked ? filter.value : '';
+            } else if (filter.inputType == 'hidden') {
+                value = filter.defaultValue;
+            } else {
+                value = filter.input.dom.value;
+            }
+            return value;
+        },
+
+        addFilterFunctionToCriteria: function(filter, func, buildingCriteria, roomCriteria) {
+            if (filter.filterType == 'building') {
+                buildingCriteria.push(func);
+            } else {
+                roomCriteria.push(func);
+            }
+        },
+
+        addFiltersToCriteria: function(filters, buildingCriteria, roomCriteria) {
+            for (var i = 0; i < filters.length; i++) {
+                filter = filters[i];
+                // check if the filter is a group of filters
+                if (filter.group !== undefined) {
+                    var value = filter.mainCheckbox.dom.checked;
+                    // the group filter shoud be enabled
+                    if (!filter.optional || value) {
+                        if (filter.property) {
+                            // a filter function that checks the specified property for the specified value
+                            var func = this.createPropertyFilter('boolean', filter.property, value);
+                            this.addFilterFunctionToCriteria(filter, func, buildingCriteria, roomCriteria);
+                        }
+                        this.addFiltersToCriteria(filter.group, buildingCriteria, roomCriteria);
+                    }
+                } else {
+                    var value = this.getFilterValue(filter);
+                    if ((!filter.optional || value) && filter.active && filter.enabled) {
+                        var func;
+                        if (filter.filterFunction) {
+                            // the first argument of the custom filter function is the calling instance
+                            // specify the calling instance (this) and derivate a proper predicate function
+                            func = curry(filter.filterFunction, this);
+                        } else {
+                            // a filter function that checks the specified property for the specified value
+                            func = this.createPropertyFilter(filter.inputType, filter.property, value);
+                        }
+                        this.addFilterFunctionToCriteria(filter, func, buildingCriteria, roomCriteria);
+                    }
+                }
+            }
+        },
+
+        resetFilteringCycle: function() {
+            this.visibleBuildingsCount = 0;
+            this.visibleRoomsCount = 0;
+
+            // the info balloons whould be re-created after each filtering
+            for (var i = 0; i < this.buildings.length; i++) {
+                var building = this.buildings[i];
+                building.marker.infoWindow = null;
+            }
+
+            // reset the counters for the aspects (areas)
+            for (var i = 0; i < this.boundCounters.length; i++) {
+                this.boundCounters[i] = 0;
+            }
+        },
+
+        filterMarkers: function() {
+            this.buttons.dom.appendChild(this.progress);
+            var mapView = this;
+            setTimeout(function() {
+                var buildingCriteria = [];
+                var roomCriteria = [];
+                mapView.resetFilteringCycle();
+                mapView.closeTooltips();
+                mapView.closeInfoBaloon();
+                mapView.addFiltersToCriteria(mapView.filters, buildingCriteria, roomCriteria);
+                mapView.filterBuildingsByCriteria(buildingCriteria, roomCriteria);
+                mapView.showMarkers();
+                mapView.showResultsInfo();
+                mapView.updateAspectsInfo();
+                mapView.buttons.dom.removeChild(mapView.progress);
+            }, 0);
+        },
+
+        showResultsInfo: function() {
+            var info = $T('Total') + ' '
+                        + this.visibleRoomsCount + ' ' + $T('room(s)')
+                        + ' / ' + this.visibleBuildingsCount + ' ' + $T('building(s)');
+            this.resultsInfo.dom.innerHTML = info;
+        },
+
+        initializeBounds: function() {
+            this.bounds = [];
+            this.boundCounters = [];
+            for (var i = 0; i < this.aspects.length; i++) {
+                var aspect = this.aspects[i];
+
+                // initialize the bounds of the area descripbed in the aspect
+                var sw = new google.maps.LatLng(aspect.topLeftLatitude, aspect.topLeftLongitude);
+                var ne = new google.maps.LatLng(aspect.bottomRightLatitude, aspect.bottomRightLongitude);
+                this.bounds.push(new google.maps.LatLngBounds(sw, ne));
+
+                // initialize the array of counters for the aspect areas
+                this.boundCounters.push(0);
+            }
+        },
+
+        updateAspectsInfo: function() {
+            for (var i = 0; i < this.aspects.length; i++) {
+                var aspect = this.aspects[i];
+                var counter = this.boundCounters[i];
+                aspect.link.dom.innerHTML = aspect.name + " (" + counter + ")";
+            }
+        },
+
+        isBrowserIE7: function() {
+            var isIE = window.ActiveXObject ? true : false;
+            var agent = navigator.userAgent.toLowerCase();
+            return isIE && /msie 7/.test(agent);
+        }
 
     },
@@ -133 +684 @@
      * Constructor of the RoomMap
      */
-    function(mapCanvas, aspectsCanvas, aspects, buildings) {
-        this.initialize(mapCanvas, aspectsCanvas, aspects, buildings);
+
+    function(mapCanvas, aspectsCanvas, filterCanvas, aspects, buildings, filters) {
+        this.initialize(mapCanvas, aspectsCanvas, filterCanvas, aspects, buildings, filters);
         this.values = {};
         this.extraComponents = [];

indico/htdocs/roomBooking.py

@@ -34 +34 @@
 def mapOfRooms(req, **params):
     return roomBooking.RHRoomBookingMapOfRooms(req).process(params)
+def mapOfRoomsWidget(req, **params):
+    return roomBooking.RHRoomBookingMapOfRoomsWidget(req).process(params)
 
 # 2. List of...