mapMarkersHandler.py - NovaBryan/EVE

mapMarkersHandler.py (25112B)
      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\ui\shared\mapView\markers\mapMarkersHandler.py
      2 import evetypes
      3 from carbon.common.script.util.timerstuff import AutoTimer
      4 from carbonui.util.color import Color
      5 from eve.client.script.ui.inflight.scannerFiles.directionalScanIntersectUtil import IsWithinScanShape
      6 from eve.client.script.ui.inflight.scannerFiles.directionalScanUtil import GetScanAngle, GetScanRangeInMeters
      7 from eve.client.script.ui.shared.mapView import mapViewConst
      8 from eve.client.script.ui.shared.mapView.markers.mapMarkerContellation import MarkerLabelConstellation
      9 from eve.client.script.ui.shared.mapView.markers.mapMarkerGroup import MarkerGroup
     10 from eve.client.script.ui.shared.mapView.markers.mapMarkerLandmark import MarkerLabelLandmark
     11 from eve.client.script.ui.shared.mapView.markers.mapMarkerRegion import MarkerLabelRegion
     12 from eve.client.script.ui.shared.mapView.markers.mapMarkerSolarSystem import MarkerLabelSolarSystem, FilterInfo
     13 from eve.client.script.ui.shared.mapView.mapViewUtil import IsDynamicMarkerType, MapPosToSolarSystemPos
     14 import geo2
     15 import telemetry
     16 from eve.client.script.ui.inflight.overview.overviewConst import OVERVIEW_AUTO_PILOT_DESTINATION_COLOR
     17 from eve.client.script.ui.shared.mapView.markers.pendingAbstractMarkerUpdater import PendingAbstractMarkerUpdater
     18 from eve.common.script.sys import idCheckers
     19 
     20 @telemetry.ZONE_METHOD
     21 def DoMarkersIntersect(marker1Bound, marker2Bound):
     22     l1, t1, r1, b1 = marker1Bound
     23     l2, t2, r2, b2 = marker2Bound
     24     overlapX = not (r1 <= l2 or l1 >= r2)
     25     if overlapX:
     26         overlapY = not (b1 <= t2 or t1 >= b2)
     27         if overlapY:
     28             return True
     29     return False
     30 
     31 
     32 @telemetry.ZONE_METHOD
     33 def FindOverlaps(markers):
     34     isOverlapped = set()
     35     isOverlapping = {}
     36     for _sortVal, (bound1, marker1) in markers:
     37         if marker1.markerID in isOverlapped:
     38             continue
     39         for _sortVal, (bound2, marker2) in markers:
     40             if marker1 is marker2:
     41                 continue
     42             if marker2.markerID in isOverlapped:
     43                 continue
     44             intersect = DoMarkersIntersect(bound1, bound2)
     45             if intersect:
     46                 isOverlapping.setdefault(marker1.markerID, []).append(marker2)
     47                 isOverlapped.add(marker2.markerID)
     48 
     49     return (isOverlapping, isOverlapped)
     50 
     51 
     52 def GetMarkerGroupsForZoomLevel(markersObjects, zoomLevel):
     53     groups = {}
     54     itemIDs = {}
     55     for markerObject in markersObjects:
     56         if markerObject.isGrouped:
     57             groupID, itemID = markerObject.GetGroupingId(zoomLevel)
     58             if itemID not in itemIDs:
     59                 itemIDs[groupID] = itemID
     60             if groupID is not None:
     61                 if groupID not in groups:
     62                     groups[groupID] = []
     63                 groups[groupID].append(markerObject)
     64 
     65     groupedMarkers = {}
     66     for groupID, groupMarkers in groups.items():
     67         if len(groupMarkers) <= 1:
     68             continue
     69         positions = [ marker.position for marker in groupMarkers ]
     70         centroid = GetMeanPosition(positions)
     71         groupedMarkers[groupID] = {'centroid': tuple(centroid),
     72          'itemID': itemIDs[groupID],
     73          'markers': groupMarkers}
     74 
     75     return groupedMarkers
     76 
     77 
     78 def GetMeanPosition(positions):
     79     if not positions:
     80         return (0, 0, 0)
     81     x_sum = sum((pos[0] for pos in positions))
     82     y_sum = sum((pos[1] for pos in positions))
     83     z_sum = sum((pos[2] for pos in positions))
     84     count = len(positions)
     85     return (x_sum / count, y_sum / count, z_sum / count)
     86 
     87 
     88 class MapViewMarkersHandler(object):
     89     __notifyevents__ = ['OnDirectionalScannerShowCone',
     90      'OnDirectionalScanStarted',
     91      'OnDestinationSet',
     92      'OnNewState',
     93      'OnSecurityModified']
     94     __metaclass__ = telemetry.ZONE_PER_METHOD
     95     projectBrackets = None
     96     markerCurveSet = None
     97     markerLayer = None
     98     mapView = None
     99     disabledMarkers = None
    100     eventHandler = None
    101     clickTimer = None
    102     cameraTranslationFromParent = 1.0
    103     cameraZoomValue = 1.0
    104     cameraProjectionFovConst = 1.0
    105 
    106     def __init__(self, mapView, markerCurveSet, markerLayer, eventHandler = None, stackMarkers = True, updateInterval = 500, isAbstractMode = False):
    107         sm.RegisterNotify(self)
    108         self.mapView = mapView
    109         self.projectBrackets = {}
    110         self.hilightMarkers = set()
    111         self.activeMarkers = set()
    112         self.groupedMarkers = set()
    113         self.previewBubbleMarkerIDs = set()
    114         self.selectedMarkerIDs = set()
    115         self.overlapMarkers = set()
    116         self.distanceSortedMarkers = set()
    117         self.activeGroups = set()
    118         self.removedGroups = set()
    119         self.markerCurveSet = markerCurveSet
    120         self.markerLayer = markerLayer
    121         self.eventHandler = eventHandler
    122         self.stackMarkers = stackMarkers
    123         self.updateTimer = AutoTimer(updateInterval, self.UpdateMarkers)
    124         self.isRegionSelected = False
    125         self.isUpdating = False
    126         self.pendingAbstractUpdater = PendingAbstractMarkerUpdater(self)
    127         self.isAbstractMode = isAbstractMode
    128 
    129     def __del__(self):
    130         sm.UnregisterNotify(self)
    131         self.StopHandler()
    132 
    133     def IsMarkerPickOverridden(self):
    134         if self.eventHandler:
    135             return self.eventHandler.MapMarkerPickingOverride()
    136         return False
    137 
    138     def GetIntersectingMarkersForMarker(self, checkMarkerObject):
    139         intersectingMarkers = []
    140         for markerID, markerObject in self.projectBrackets.iteritems():
    141             if markerObject and markerObject.markerContainer and not markerObject.markerContainer.destroyed:
    142                 intersect = DoMarkersIntersect(checkMarkerObject.GetBoundaries(), markerObject.GetBoundaries())
    143                 if intersect:
    144                     intersectingMarkers.append(markerObject)
    145 
    146         return intersectingMarkers
    147 
    148     def UpdateMarkers(self, forceUpdateGroupings = False):
    149         if self.isUpdating:
    150             return
    151         self.isUpdating = True
    152         distance_markers = []
    153         stack_markers = []
    154         activeAndHighlighted = self.hilightMarkers.union(self.activeMarkers)
    155         for markerID in activeAndHighlighted.union(self.distanceSortedMarkers):
    156             markerObject = self.projectBrackets.get(markerID, None)
    157             if markerObject and markerObject.ignoreOverlaps:
    158                 continue
    159             if markerObject and markerObject.markerContainer and not markerObject.markerContainer.destroyed:
    160                 markerDistance = markerObject.GetMarkerDistance()
    161                 distance_markers.append((markerDistance, markerObject))
    162                 if hasattr(markerObject, 'GetOverlapSortValue'):
    163                     markerBoundaries = markerObject.GetBoundaries()
    164                     stack_markers.append(((markerObject.GetOverlapSortValue(), markerDistance), (markerBoundaries, markerObject)))
    165 
    166         distanceSortedMarkers = sorted(distance_markers, reverse=True)
    167         for markerDistance, markerObject in distanceSortedMarkers:
    168             markerObject.MoveToFront()
    169 
    170         if self.stackMarkers:
    171             markersSorted = sorted(stack_markers)
    172             isOverlapping, isOverlapped = FindOverlaps(markersSorted)
    173             for sortOrderValue, (bound, markerObject) in reversed(markersSorted):
    174                 markerID = markerObject.markerID
    175                 if markerID in isOverlapping:
    176                     markerObject.RegisterOverlapMarkers(isOverlapping[markerID])
    177                 elif markerID in isOverlapped:
    178                     markerObject.SetOverlappedState(True)
    179                 else:
    180                     markerObject.SetOverlappedState(False)
    181 
    182         if len(self.groupedMarkers) > 0:
    183             zoomLevel = self.cameraZoomValue
    184             groupedMarkers = GetMarkerGroupsForZoomLevel(self.groupedMarkers, zoomLevel)
    185             needsUpdates = len(groupedMarkers) != len(self.activeGroups)
    186             if not needsUpdates:
    187                 for group in self.activeGroups:
    188                     groupID = group.GetGroupID()
    189                     if groupID not in groupedMarkers:
    190                         needsUpdates = True
    191                         break
    192 
    193             if needsUpdates or forceUpdateGroupings:
    194                 for oldGroupMarker in self.activeGroups:
    195                     for marker in oldGroupMarker.members:
    196                         marker.SetGroupingID(None)
    197 
    198                     oldGroupMarker.Close()
    199                     self.RemoveMarker(oldGroupMarker.markerID)
    200 
    201                 self.activeGroups.clear()
    202                 for groupID, groupInfo in groupedMarkers.items():
    203                     centroid = groupInfo['centroid']
    204                     markers = groupInfo['markers']
    205                     itemID = groupInfo['itemID']
    206                     for marker in markers:
    207                         marker.SetGroupingID(groupID)
    208 
    209                     if len(markers) <= 1:
    210                         continue
    211                     markerID = (mapViewConst.MARKERID_GROUP, itemID)
    212                     groupMarker = self._AddPositionMarker(markerID=markerID, groupID=groupID, position=centroid, members=markers, markerClass=MarkerGroup, hintFormat=markers[0].GetGroupingHintFormat(), isAbstractMode=self.isAbstractMode)
    213                     self.activeGroups.add(groupMarker)
    214 
    215             if len(self.removedGroups):
    216                 for removedGroup in self.removedGroups:
    217                     if removedGroup in self.activeGroups:
    218                         self.activeGroups.remove(removedGroup)
    219 
    220                 self.removedGroups.clear()
    221         self.isUpdating = False
    222 
    223     def OnNewState(self, state):
    224         self.UpdateGateMarkerYellowIfNextJump()
    225 
    226     def OnDestinationSet(self, *args):
    227         self.UpdateGateMarkerYellowIfNextJump()
    228 
    229     def UpdateGateMarkerYellowIfNextJump(self):
    230         bp = sm.GetService('michelle').GetBallpark()
    231         if not bp or not self.projectBrackets:
    232             return
    233         for marker in self.projectBrackets.values():
    234             if not marker.typeID:
    235                 continue
    236             if self.IsStargate(marker.typeID):
    237                 destinationPath = sm.GetService('starmap').GetDestinationPath()
    238                 slimItem = bp.slimItems.get(marker.itemID, None)
    239                 if slimItem:
    240                     jumpToLocationID = slimItem.jumps[0].locationID
    241                     if destinationPath and jumpToLocationID == destinationPath[0]:
    242                         iconColor = OVERVIEW_AUTO_PILOT_DESTINATION_COLOR
    243                     else:
    244                         iconColor = Color.WHITE
    245                     marker.SetIconColor(iconColor)
    246 
    247     def OnSecurityModified(self, solar_system_id, modifier_amount, new_security):
    248         marker = self.GetMarkerByID(solar_system_id)
    249         if marker is not None:
    250             marker.UpdateLabelText()
    251 
    252     def IsStargate(self, typeID):
    253         return evetypes.GetGroupID(typeID) == const.groupStargate
    254 
    255     def UpdateDscanHilite(self, direction, egoPos):
    256         egoPos = MapPosToSolarSystemPos(egoPos)
    257         range = GetScanRangeInMeters()
    258         angle = GetScanAngle()
    259         for marker in self.projectBrackets.values():
    260             pos = marker.GetDisplayPosition()
    261             if pos == egoPos:
    262                 continue
    263             pos = MapPosToSolarSystemPos(pos)
    264             if not marker.IsPartialResult() and IsWithinScanShape(pos, egoPos, angle, range, direction):
    265                 marker.ShowDscanHilite()
    266             else:
    267                 marker.HideDscanHilite()
    268 
    269     def HideAllDscanHilite(self):
    270         for marker in self.projectBrackets.values():
    271             marker.HideDscanHilite()
    272 
    273     def OnDirectionalScanStarted(self):
    274         if not self.projectBrackets:
    275             return
    276         for marker in self.projectBrackets.values():
    277             if marker.IsDscanHiliteShown():
    278                 marker.AnimBlinkDscanHilite()
    279 
    280     def OnDirectionalScannerShowCone(self, isShown):
    281         if not isShown:
    282             self.HideAllDscanHilite()
    283 
    284     def GetExtraMouseOverInfoForMarker(self, markerID):
    285         if self.mapView:
    286             return self.mapView.GetExtraMouseOverInfoForItemID(markerID)
    287 
    288     def ReloadAll(self):
    289         for markerID, markerObject in self.projectBrackets.iteritems():
    290             if markerObject:
    291                 markerObject.Reload()
    292 
    293     def ReloadAllAbstractBrackets(self, isAbstractMode = False):
    294         self.isAbstractMode = isAbstractMode
    295         for markerID, markerObject in self.projectBrackets.iteritems():
    296             if hasattr(markerObject, 'ResetAbstractMode'):
    297                 markerObject.ResetAbstractMode(isAbstractMode)
    298 
    299     def _IsSolarSystemMarker(self, markerObject):
    300         return markerObject and isinstance(markerObject, MarkerLabelSolarSystem)
    301 
    302     def _IsGroupMaker(self, markerObject):
    303         return markerObject and isinstance(markerObject, MarkerGroup)
    304 
    305     def SetDisplayStateOverrideFilter(self, markersToShow):
    306         filtering = bool(markersToShow)
    307         for markerID, markerObject in self.projectBrackets.iteritems():
    308             if IsDynamicMarkerType(markerObject.markerID):
    309                 continue
    310             if not filtering or markerID in markersToShow:
    311                 markerObject.displayStateOverride = None
    312             else:
    313                 markerObject.displayStateOverride = False
    314 
    315     def SetDisplayStateOverrideFilterFalseForSystems(self):
    316         for markerID, markerObject in self.projectBrackets.iteritems():
    317             if self._IsSolarSystemMarker(markerObject):
    318                 markerObject.displayStateOverride = False
    319 
    320     def UpdateMarkerPositions(self, changedSolarSystemPositions):
    321         for markerID, markerObject in self.projectBrackets.iteritems():
    322             if hasattr(markerObject, 'UpdateSolarSystemPosition') and markerObject.solarSystemID in changedSolarSystemPositions:
    323                 mapNode = changedSolarSystemPositions[markerObject.solarSystemID]
    324                 markerObject.UpdateSolarSystemPosition(mapNode.position)
    325 
    326     def UpdateRegionMarkerPositions(self, newPosByRegionID):
    327         for regionID, coordinates in newPosByRegionID.iteritems():
    328             markerObject = self.projectBrackets.get(regionID, None)
    329             if not markerObject:
    330                 continue
    331             if hasattr(markerObject, 'UpdateRegionPosition'):
    332                 markerObject.UpdateRegionPosition(coordinates)
    333 
    334     def UpdateConstellationMarkerPositions(self, newPosByConstellationID):
    335         for constellationID, coordinates in newPosByConstellationID.iteritems():
    336             markerObject = self.projectBrackets.get(constellationID, None)
    337             if not markerObject:
    338                 continue
    339             if hasattr(markerObject, 'UpdateConstellationPosition'):
    340                 markerObject.UpdateConstellationPosition(coordinates)
    341 
    342     def UpdateMarkerTransitionState(self, markerIDs, isTransitioning):
    343         for markerID in markerIDs:
    344             markerObject = self.projectBrackets.get(markerID, None)
    345             if not markerObject:
    346                 continue
    347             if getattr(markerObject, 'SetMapTransitioning', None):
    348                 markerObject.SetMapTransitioning(isTransitioning)
    349 
    350     def UpdateLandmarkMarkerPositions(self, newPosByLandmarkID):
    351         for landmarkID, coordinates in newPosByLandmarkID.iteritems():
    352             markerObject = self.projectBrackets.get(landmarkID, None)
    353             if not markerObject:
    354                 continue
    355             if hasattr(markerObject, 'UpdateLandmarkPosition'):
    356                 markerObject.UpdateLandmarkPosition(coordinates)
    357 
    358     def StopHandler(self):
    359         self.updateTimer = None
    360         if self.projectBrackets:
    361             for markerID, markerObject in self.projectBrackets.iteritems():
    362                 markerObject.Close()
    363 
    364         self.projectBrackets = None
    365         self.mapView = None
    366         self.markerLayer = None
    367         self.markerCurveSet = None
    368         self.eventHandler = None
    369         if self.pendingAbstractUpdater:
    370             self.pendingAbstractUpdater.Kill()
    371             self.pendingAbstractUpdater = None
    372 
    373     def OnMarkerMouseEnter(self, marker):
    374         self.mapView.OnMarkerHovered(marker.markerID)
    375 
    376     def OnMarkerMouseExit(self, marker):
    377         self.mapView.OnMarkerHovered(None)
    378 
    379     def OnMarkerSelected(self, marker):
    380         self.isRegionSelected = marker and idCheckers.IsRegion(marker.markerID)
    381         self.mapView.SetSelectedMarker(marker)
    382 
    383     def HilightMarkers(self, markerIDs, add = False):
    384         hilightMarkers = markerIDs
    385         if not add:
    386             for oldMarkerID in self.hilightMarkers:
    387                 if oldMarkerID not in hilightMarkers:
    388                     oldMarker = self.GetMarkerByID(oldMarkerID)
    389                     if oldMarker:
    390                         oldMarker.SetHilightState(False)
    391 
    392         for newMarkerID in hilightMarkers:
    393             newMarker = self.GetMarkerByID(newMarkerID)
    394             if newMarker:
    395                 newMarker.SetHilightState(True)
    396 
    397         if add:
    398             self.hilightMarkers = self.hilightMarkers.union(set(hilightMarkers))
    399         else:
    400             self.hilightMarkers = set(hilightMarkers)
    401 
    402     def SetPreviewBubbleMarkers(self, markerIDsSet):
    403         if markerIDsSet:
    404             noLongerVisible = self.previewBubbleMarkerIDs.difference(markerIDsSet)
    405             newTubeBubbles = markerIDsSet.difference(self.previewBubbleMarkerIDs)
    406         else:
    407             noLongerVisible = self.previewBubbleMarkerIDs
    408             newTubeBubbles = set()
    409         self.previewBubbleMarkerIDs = set(markerIDsSet) if markerIDsSet else set()
    410         for oldMarkerID in noLongerVisible:
    411             oldMarker = self.GetMarkerByID(oldMarkerID)
    412             if oldMarker:
    413                 oldMarker.SetPreviewState(False)
    414 
    415         for newMarkerID in newTubeBubbles:
    416             newMarker = self.GetMarkerByID(newMarkerID)
    417             if newMarker:
    418                 newMarker.SetPreviewState(True)
    419 
    420     def UpdateMarkerState(self, markerIDs, selectedMarkerIDs = None):
    421         for oldMarkerID in self.activeMarkers:
    422             if oldMarkerID not in markerIDs:
    423                 oldMarker = self.GetMarkerByID(oldMarkerID)
    424                 if oldMarker:
    425                     oldMarker.SetActiveState(mapViewConst.MARKER_INACTIVE)
    426 
    427         for newMarkerID in markerIDs:
    428             newMarker = self.GetMarkerByID(newMarkerID)
    429             if newMarker:
    430                 if newMarkerID in selectedMarkerIDs:
    431                     newMarker.SetActiveState(mapViewConst.MARKER_SELECTED)
    432                 else:
    433                     newMarker.SetActiveState(mapViewConst.MARKER_ACTIVE)
    434 
    435         self.selectedMarkerIDs = set(selectedMarkerIDs)
    436         self.activeMarkers = set(markerIDs)
    437 
    438     def RefreshActiveAndHilightedMarkers(self):
    439         for marker in self.GetActiveAndHilightedMarkers():
    440             marker.UpdateActiveAndHilightState()
    441 
    442     def GetActiveAndHilightedMarkers(self):
    443         ret = set()
    444         for markerID in self.hilightMarkers.union(self.activeMarkers):
    445             marker = self.GetMarkerByID(markerID)
    446             if marker:
    447                 ret.add(marker)
    448 
    449         return ret
    450 
    451     def GetMarkerState(self, markerID):
    452         if markerID in self.selectedMarkerIDs:
    453             return mapViewConst.MARKER_SELECTED
    454         elif markerID in self.activeMarkers:
    455             return mapViewConst.MARKER_ACTIVE
    456         else:
    457             return mapViewConst.MARKER_INACTIVE
    458 
    459     def IsActiveOrHilighted(self, markerID):
    460         return markerID in self.activeMarkers or markerID in self.hilightMarkers
    461 
    462     def IsHilighted(self, markerID):
    463         return markerID in self.hilightMarkers
    464 
    465     def IsSelected(self, markerID):
    466         return markerID in self.selectedMarkerIDs
    467 
    468     def IsRegionSelected(self):
    469         return self.isRegionSelected
    470 
    471     def RemoveMarker(self, markerID, fadeOut = False):
    472         try:
    473             self.overlapMarkers.remove(markerID)
    474         except:
    475             pass
    476 
    477         try:
    478             self.distanceSortedMarkers.remove(markerID)
    479         except:
    480             pass
    481 
    482         markerObject = self.projectBrackets.pop(markerID, None)
    483         if markerObject:
    484             if markerObject.isGrouped:
    485                 currentGroupID = markerObject.GetCurrentGroupID()
    486                 if currentGroupID:
    487                     emptyGroups = []
    488                     for groupMarker in self.activeGroups:
    489                         if groupMarker.GetGroupID() == currentGroupID:
    490                             groupMarker.RemoveMember(markerObject)
    491                             if len(groupMarker.members) == 1:
    492                                 lastMember = groupMarker.members[0]
    493                                 lastMember.SetGroupingID(None)
    494                                 emptyGroups.append(groupMarker)
    495 
    496                     for emptyGroup in emptyGroups:
    497                         emptyGroup.Close()
    498                         self.RemoveMarker(emptyGroup.markerID)
    499                         self.removedGroups.add(emptyGroup)
    500 
    501                 try:
    502                     self.groupedMarkers.remove(markerObject)
    503                 except:
    504                     pass
    505 
    506             if fadeOut:
    507                 markerObject.FadeOutAndClose()
    508             else:
    509                 markerObject.Close()
    510 
    511     def RemoveMarkersByType(self, markerType):
    512         markers = self.GetMarkersByType(markerType)
    513         markerIDs = set([ markerObject.markerID for markerObject in markers ])
    514         for markerID in markerIDs:
    515             self.RemoveMarker(markerID)
    516 
    517     def GetMarkerByID(self, markerID):
    518         return self.projectBrackets.get(markerID, None)
    519 
    520     def GetMarkersByType(self, markerType):
    521         return [ markerObject for markerID, markerObject in self.projectBrackets.iteritems() if isinstance(markerID, tuple) and markerID[0] == markerType ]
    522 
    523     def _AddPositionMarker(self, **kwds):
    524         markerID = kwds.get('markerID', None)
    525         if self.projectBrackets is not None and markerID in self.projectBrackets:
    526             return self.projectBrackets[markerID]
    527         if 'parentContainer' not in kwds:
    528             kwds['parentContainer'] = self.markerLayer
    529         kwds['curveSet'] = self.markerCurveSet
    530         kwds['markerHandler'] = self
    531         kwds['eventHandler'] = self.eventHandler
    532         markerClass = kwds.get('markerClass', None)
    533         markerObject = markerClass(**kwds)
    534         if self.projectBrackets is not None:
    535             self.projectBrackets[markerID] = markerObject
    536         markerObject.SetActiveState(self.GetMarkerState(markerID))
    537         if markerObject.isGrouped:
    538             self.groupedMarkers.add(markerObject)
    539         return markerObject
    540 
    541     def RegisterMarker(self, markerObject):
    542         self.projectBrackets[markerObject.markerID] = markerObject
    543 
    544     def AddSolarSystemMarker(self, markerID, position, **kwds):
    545         return self.AddSolarSystemBasedMarker(markerID=markerID, solarSystemID=markerID, mapPositionSolarSystem=position, mapPositionLocal=(0, 0, 0), markerClass=MarkerLabelSolarSystem, **kwds)
    546 
    547     def AddConstellationMarker(self, markerID, position, **kwds):
    548         return self._AddPositionMarker(markerID=markerID, position=position, markerClass=MarkerLabelConstellation, **kwds)
    549 
    550     def AddRegionMarker(self, markerID, position, **kwds):
    551         return self._AddPositionMarker(markerID=markerID, position=position, markerClass=MarkerLabelRegion, **kwds)
    552 
    553     def AddLandmarkMarker(self, markerID, position, **kwds):
    554         return self._AddPositionMarker(markerID=markerID, position=position, markerClass=MarkerLabelLandmark, **kwds)
    555 
    556     def AddSolarSystemBasedMarker(self, markerID, markerClass, **kwds):
    557         if getattr(markerClass, 'distanceSortEnabled', False):
    558             self.distanceSortedMarkers.add(markerID)
    559             if getattr(markerClass, 'overlapEnabled', False):
    560                 self.overlapMarkers.add(markerID)
    561         position = geo2.Vec3Add(kwds['mapPositionSolarSystem'], kwds['mapPositionLocal'])
    562         return self._AddPositionMarker(markerID=markerID, position=position, markerClass=markerClass, **kwds)
    563 
    564     def RegisterCameraTranslationFromParent(self, cameraTranslationFromParent):
    565         self.cameraTranslationFromParent = cameraTranslationFromParent
    566 
    567     def RegisterCameraZoomValue(self, cameraZoomValue):
    568         self.cameraZoomValue = cameraZoomValue
    569 
    570     def RegisterCameraProjectionFov(self, value):
    571         self.cameraProjectionFovConst = value
    572 
    573     def GetViewportValues(self):
    574         return (self.cameraZoomValue,
    575          self.cameraProjectionFovConst,
    576          self.mapView.camera.viewport.width,
    577          self.mapView.camera.viewport.height)
    578 
    579     def UpdateMarkersWithFilters(self, activeFilter):
    580         if activeFilter is None:
    581             return
    582         amountFmtFunc = activeFilter.GetAmountFmtFunc()
    583         for markerID, markerObject in self.projectBrackets.iteritems():
    584             if self._IsSolarSystemMarker(markerObject):
    585                 filterInfo = FilterInfo(activeFilter.GetStarColor(markerID), activeFilter.GetAmountForSolarSystem(markerID), activeFilter.GetTexturePathForSolarSystem(markerID), activeFilter.GetTextureColorForSolarSystem(markerID), amountFmtFunc)
    586                 markerObject.UpdateFilterInfo(filterInfo)
	NovaBryan/EVE_Dump
	Log \| Files \| 📦 下载最新源码 (.zip) \| Refs \| README