C++ ODPoint类代码示例

bool ODSelect::DeleteSelectablePoint( void *pdata, int SeltypeToDelete )
{
    SelectItem *pFindSel;

    if( NULL != pdata ) {
//    Iterate on the list
        wxSelectableItemListNode *node = pSelectList->GetFirst();

        while( node ) {
            pFindSel = node->GetData();
            if( pFindSel->m_seltype == SeltypeToDelete ) {
                if( pdata == pFindSel->m_pData1 ) {
                    delete pFindSel;
                    delete node;
                    g_pRolloverPoint = NULL;
                    
                    if( SELTYPE_ODPOINT == SeltypeToDelete ){
                        ODPoint *prp = (ODPoint *)pdata;
                        prp->SetSelectNode( NULL );
                    }
                    
                    return true;
                }
            }
            node = node->GetNext();
        }
    }
    return false;
}

void EBL::MoveEndPoint( bool bUpdateEBL )
{
    ODPoint *pEndPoint = m_pODPointList->GetLast()->GetData();
    ODPoint *pStartPoint = m_pODPointList->GetFirst()->GetData();

    if(m_dLength == 0.) m_dLength = pEndPoint->m_seg_len;
    
    if(m_bRotateWithBoat) {
        MaintainWith();
    } else {
        if(!m_bFixedEndPosition)
            PositionBearingDistanceMercator_Plugin(pStartPoint->m_lat, pStartPoint->m_lon, m_dEBLAngle, m_dLength, &pEndPoint->m_lat, &pEndPoint->m_lon);
    }
    
    if(m_bVRM)
        pStartPoint->SetODPointRangeRingsStep( m_dLength / pStartPoint->GetODPointRangeRingsNumber() );
    
    if(g_pEBLPropDialog && g_pEBLPropDialog->IsShown())
        g_pEBLPropDialog->UpdateProperties();
    
    if(bUpdateEBL) {
        bool l_bSaveUpdatesState = m_bSaveUpdates;
        m_bSaveUpdates = true;
        UpdateEBL();
        m_bSaveUpdates = l_bSaveUpdatesState;
    } else
        UpdateEBL();
}

ODPoint *Boundary::InsertPointAfter( ODPoint *pOP, double lat, double lon, bool bRenamePoints )
{
    ODPoint *newpoint = ODPath::InsertPointAfter( pOP, lat, lon, bRenamePoints );
    newpoint->SetTypeString( wxT("Boundary Point") );
    
    return ( newpoint );
}

void EBL::MoveEndPoint( void )
{
    ODPoint *pEndPoint = m_pODPointList->GetLast()->GetData();
    ODPoint *pStartPoint = m_pODPointList->GetFirst()->GetData();
    DistanceBearingMercator_Plugin(pEndPoint->m_lat, pEndPoint->m_lon, pStartPoint->m_lat, pStartPoint->m_lon, &m_dEBLAngle, &m_dLength);
    if(m_bRotateWithBoat) {
        switch(m_iMaintainWith) {
            case ID_EBL_MAINTAIN_WITH_HEADING:
                m_dEBLAngle -= g_pfFix.Hdt;
                break;
            case ID_EBL_MAINTAIN_WITH_COG:
                m_dEBLAngle -= g_pfFix.Cog;
                break;
        }
    }
    m_dBoatHeading = g_pfFix.Hdt;
    m_dBoatCOG = g_pfFix.Cog;

    if(m_bVRM) {
        ODPoint *pStartPoint = m_pODPointList->GetFirst()->GetData();
        pStartPoint->SetODPointRangeRingsStep( m_dLength / pStartPoint->GetODPointRangeRingsNumber() );
    }
    if(g_pEBLPropDialog && g_pEBLPropDialog->IsShown())
        g_pEBLPropDialog->UpdateProperties();
    
}

void EBL::DrawGL( PlugIn_ViewPort &piVP )
{
    if(m_bVRM) {
        ODPoint *pStartPoint = m_pODPointList->GetFirst()->GetData();
        ODPoint *pEndPoint = m_pODPointList->GetLast()->GetData();
        pStartPoint->SetODPointRangeRingsStep( pEndPoint->m_seg_len / pStartPoint->GetODPointRangeRingsNumber() );
    }
    ODPath::DrawGL( piVP );
}

void EBL::MoveEndPoint( double inc_lat, double inc_lon )
{
    ODPoint *pEndPoint = m_pODPointList->GetLast()->GetData();
    pEndPoint->m_lat -= inc_lat;
    pEndPoint->m_lon -= inc_lon;
    if(m_bVRM) {
        ODPoint *pStartPoint = m_pODPointList->GetFirst()->GetData();
        pStartPoint->SetODPointRangeRingsStep( pEndPoint->m_seg_len / pStartPoint->GetODPointRangeRingsNumber() );
    }
    if(g_pEBLPropDialog && g_pEBLPropDialog->IsShown())
        g_pEBLPropDialog->UpdateProperties();
}

BoundaryPoint *PointMan::FindLineCrossingBoundaryPtr( double StartLon, double StartLat, double EndLon, double EndLat, int type, int state )
{
    // search boundary point
    wxODPointListNode *node = GetODPointList()->GetFirst();
    while( node ) {
        ODPoint *od = static_cast<ODPoint *>(node->GetData());
        if( od->IsListed() ) {
            if( od->m_bIsInPath && !od->m_bKeepXPath ) {
                node = node->GetNext();
                continue;
            }
            // if there's no ring there's nothing to do
            if (!od->GetShowODPointRangeRings() || 
                    od->GetODPointRangeRingsNumber() == 0 ||
                    od->GetODPointRangeRingsStep() == 0.f)
            {
                node = node->GetNext();
                continue;
            }
            BoundaryPoint *op = dynamic_cast<BoundaryPoint *>(node->GetData());
            if (!op) {
                node = node->GetNext();
                continue;
            }
            bool l_bNext = false;
            switch (type) {
                case ID_BOUNDARY_ANY:
                    l_bNext = false;
                    break;
                case ID_BOUNDARY_EXCLUSION:
                    if(!op->m_bExclusionBoundaryPoint) l_bNext = true;
                    break;
                case ID_BOUNDARY_INCLUSION:
                    if(!op->m_bInclusionBoundaryPoint) l_bNext = true;
                    break;
                case ID_BOUNDARY_NIETHER:
                    if(op->m_bExclusionBoundaryPoint || op->m_bInclusionBoundaryPoint) l_bNext = true;
                    break;
            }
            if (!l_bNext) {
               // 0 nautical miles 1 kilometer
               double f = (op->m_iODPointRangeRingsStepUnits == 1)?1000.0:1852.31;
               // in meters
               double dst = op->GetODPointRangeRingsNumber() * op->GetODPointRangeRingsStep() * f;
               if (DistancePointLine( op->m_lon, op->m_lat, StartLon, StartLat, EndLon, EndLat, dst )) {
                  return op;
               }
            }
        }
        node = node->GetNext();
    }
    return 0;
}

void PointMan::SetColorScheme( PI_ColorScheme cs )
{
    //ProcessIcons( g_ODStyleManager->GetCurrentStyle() );

    //    Iterate on the ODPoint list, requiring each to reload icon
    m_ColourScheme = cs;
    wxODPointListNode *node = m_pODPointList->GetFirst();
    while( node ) {
        ODPoint *pr = node->GetData();
        pr->SetColourScheme(cs);
        pr->ReLoadIcon();
        node = node->GetNext();
    }
}

void EBL::AddPoint( ODPoint *pNewPoint, bool b_rename_in_sequence, bool b_deferBoxCalc, bool b_isLoading )
{
    ODPath::AddPoint( pNewPoint, b_rename_in_sequence, b_deferBoxCalc, b_isLoading );
    if(pNewPoint->m_ODPointName == _("Start") || pNewPoint->m_ODPointName == _("Boat")) {
        pNewPoint->SetODPointRangeRingsNumber( 1 );
        pNewPoint->SetODPointRangeRingsStep( 0 );
        pNewPoint->SetODPointRangeRingsColour( GetCurrentColour() );
        if(m_bVRM)
            pNewPoint->m_bShowODPointRangeRings = true;
        else
            pNewPoint->m_bShowODPointRangeRings = false;
    } else if(pNewPoint->m_ODPointName == _("End")) {
        ODPoint *pFirstPoint = m_pODPointList->GetFirst()->GetData();
        pFirstPoint->SetODPointRangeRingsStep( pNewPoint->m_seg_len );
    }
}

void PathProp::OnPathPropMenuSelected( wxCommandEvent& event )
{
    switch( event.GetId() ) {
        case ID_PATHPROP_MENU_DELETE: {
            long item = -1;
            item = m_opList->GetNextItem( item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
            if( item == -1 ) break;

            ODPoint *op;
            op = (ODPoint *) m_opList->GetItemData( item );

            wxString sMessage( wxS("Are you sure you want to remove this ") );
            wxString sCaption( wxS("OCPN Draw Remove ") );
            wxString sType( wxS("") );
            if (!op || op->GetTypeString().IsNull() || op->GetTypeString().IsEmpty() )
                sType.append( wxS("Point") );
            else
                sType.append( op->GetTypeString() );
            sMessage.append( sType );
            sMessage.append( wxS("?") );
            sCaption.append( sType );
            
            int dlg_return = OCPNMessageBox_PlugIn( this, sMessage, sCaption, (long) wxYES_NO | wxCANCEL | wxYES_DEFAULT );

            if( dlg_return == wxID_YES ) {
                m_pPath->RemovePointFromPath( op, m_pPath );
            }
            break;
        }
        case ID_PATHPROP_MENU_EDIT_WP: {
            long item = -1;

            item = m_opList->GetNextItem( item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );

            if( item == -1 ) break;

            ODPoint *op = (ODPoint *) m_opList->GetItemData( item );
            if( !op ) break;

            PathManagerDialog::ODPointShowPropertiesDialog( op, this );
            break;
        }
    }
}

void EBL::CentreOnLatLon( double lat, double lon )
{
    ODPoint *pStartPoint = m_pODPointList->GetFirst()->GetData();
    pStartPoint->m_lat = lat;
    pStartPoint->m_lon = lon;
    pStartPoint->m_ODPointName = _("Start");
    if(pStartPoint->GetIconName() != wxEmptyString) {
        pStartPoint->SetIconName( g_sEBLStartIconName );
        pStartPoint->ReLoadIcon();
    }
    m_bCentreOnBoat = false;
    m_bSaveUpdates = true;
    
    UpdateEBL();
    if(g_pEBLPropDialog && g_pEBLPropDialog->IsShown())
        g_pEBLPropDialog->UpdateProperties();
    
    RequestRefresh( g_ocpn_draw_pi->m_parent_window );
    return;
}

bool PathProp::UpdateProperties( Path *pPath )
{
    if( NULL == pPath ) return false;

    ::wxBeginBusyCursor();

    m_PathNameCtl->SetValue( pPath->m_PathNameString );
    m_textDescription->SetValue( pPath->m_PathDescription);
    m_pPathActive->SetValue( pPath->IsActive() );

    double brg;
    double join_distance = 0.;
    ODPoint *first_point = pPath->GetPoint( 1 );
    if( first_point )
        DistanceBearingMercator_Plugin( first_point->m_lat, first_point->m_lon, g_dLat, g_dLon, &brg, &join_distance );

    //    Update the "tides event" column header
    wxListItem column_info;
    if( m_opList->GetColumn( 6, column_info ) ) {
        wxString c = _("Next tide event");
        if( gpIDX && m_starttime.IsValid() ) {
            c = _T("@~~");
            c.Append( wxString( gpIDX->IDX_station_name, wxConvUTF8 ) );
            int i = c.Find( ',' );
            if( i != wxNOT_FOUND ) c.Remove( i );

        }
        column_info.SetText( c );
        m_opList->SetColumn( 6, column_info );
    }

    //  Total length
    double total_length = pPath->m_path_length;

    wxString slen;
    slen.Printf( wxT("%5.2f ") + getUsrDistanceUnit_Plugin(), toUsrDistance_Plugin( total_length ) );
    m_TotalDistCtl->SetValue( slen );

    wxString time_form;
    wxString tide_form;

    //  Iterate on Route Points
    wxODPointListNode *node = pPath->m_pODPointList->GetFirst();

    int i = 0;
    double slat = g_dLat;
    double slon = g_dLon;

    int stopover_count = 0;
    bool arrival = true; // marks which pass over the wpt we do - 1. arrival 2. departure
    bool enroute = true; // for active route, skip all points up to the active point

    wxString nullify = _T("----");
    
    while( node ) {
        ODPoint *prp = node->GetData();
        long item_line_index = i + stopover_count;

        //  Leg
        wxString t;
        t.Printf( _T("%d"), i );
        if( i == 0 ) t = _T("Boat");
        if( arrival ) m_opList->SetItem( item_line_index, 0, t );

        //  Mark Name
        if( arrival ) m_opList->SetItem( item_line_index, 1, prp->GetName() );
    // Store Dewcription
        if( arrival ) m_opList->SetItem( item_line_index, 8, prp->GetDescription() );

        //  Distance
        //  Note that Distance/Bearing for Leg 000 is as from current position

        double brg, leg_dist;
        bool starting_point = false;

        starting_point = ( i == 0 ) && enroute;
        if( m_pEnroutePoint && !starting_point ) starting_point = ( prp->m_GUID
                == m_pEnroutePoint->m_GUID );

        DistanceBearingMercator_Plugin( prp->m_lat, prp->m_lon, slat, slon, &brg, &leg_dist );

    // calculation of course at current WayPoint.
    double course=10, tmp_leg_dist=23;
    wxODPointListNode *next_node = node->GetNext();
    ODPoint * _next_prp = (next_node)? next_node->GetData(): NULL;
    if (_next_prp )
    {
        DistanceBearingMercator_Plugin( _next_prp->m_lat, _next_prp->m_lon, prp->m_lat, prp->m_lon, &course, &tmp_leg_dist );
    }else
    {
      course = 0.0;
      tmp_leg_dist = 0.0;
    }

    //prp->SetCourse(course); // save the course to the next waypoint for printing.
    // end of calculation


    t.Printf( _T("%6.2f ") + getUsrDistanceUnit_Plugin(), toUsrDistance_Plugin( leg_dist ) );
    if( arrival )
//.........这里部分代码省略.........

bool EBLProp::SaveChanges( void )
{
    wxColour l_EBLOrigColour = m_pEBL->GetCurrentColour();
    ODPoint *pFirstPoint = m_pEBL->m_pODPointList->GetFirst()->GetData();

    bool l_bUpdatePath = false;
    double l_dLength;
    m_textCtrlTotalLength->GetValue().ToDouble( &l_dLength );
    l_dLength = fromUsrDistance_Plugin( l_dLength );
    if(m_pEBL->m_dLength != l_dLength) {
        l_bUpdatePath = true;
        m_pEBL->m_dLength = l_dLength;
    }
    
    if(pFirstPoint->GetODPointRangeRingsColour() == l_EBLOrigColour)
        pFirstPoint->SetODPointRangeRingsColour( m_pEBL->GetCurrentColour() );

    m_pEBL->m_bFixedEndPosition = m_checkBoxEBLFixedEndPosition->GetValue();
    m_pEBL->m_iPersistenceType = m_radioBoxPathPersistence->GetSelection();
    if(m_pEBL->m_iPersistenceType == ID_NOT_PERSISTENT || m_pEBL->m_iPersistenceType == ID_PERSISTENT_CRASH)
        m_pEBL->m_bTemporary = true;
    else
        m_pEBL->m_bTemporary = false;

    m_pEBL->m_bRotateWithBoat = m_checkBoxRotateWithBoat->GetValue();
    if(m_pEBL->m_bRotateWithBoat)
        m_pEBL->m_bFixedEndPosition = false;
    m_pEBL->m_iMaintainWith = m_radioBoxMaintainWith->GetSelection();
    
    double l_dEBLAngle;
    m_textCtrlEBLAngle->GetValue().ToDouble( &l_dEBLAngle );
    if(m_pEBL->m_bRotateWithBoat) {
        if(l_dEBLAngle != m_pEBL->m_dEBLAngle) {
            l_bUpdatePath = true;
            m_pEBL->m_dEBLAngle = l_dEBLAngle;
        }
    } else if(!m_pEBL->m_bFixedEndPosition) {
        switch (m_pEBL->m_iMaintainWith) {
            case ID_MAINTAIN_WITH_HEADING:
                m_pEBL->m_dEBLAngle = l_dEBLAngle + g_pfFix.Hdm;
                break;
            case ID_MAINTAIN_WITH_COG:
                m_pEBL->m_dEBLAngle = l_dEBLAngle + g_pfFix.Cog;
                break;
        }
    }

    if(l_bUpdatePath)
        m_pEBL->MoveEndPoint(true);

    m_pEBL->m_bDrawArrow = m_checkBoxPathShowArrow->GetValue();
    m_pEBL->m_bVRM = m_checkBoxShowVRM->GetValue();
    m_pEBL->m_bAlwaysShowInfo = m_checkBoxShowEBLInfo->GetValue();
    if(m_pEBL->m_bVRM) {
        pFirstPoint->m_bShowODPointRangeRings = true;
    } else
        pFirstPoint->m_bShowODPointRangeRings = false;
    m_pEBL->m_bPerpLine = m_checkBoxShowPerpLine->GetValue();

    bool ret = ODPathPropertiesDialogImpl::SaveChanges();
    
    return ret;
}

void ODDRDialogImpl::OnOK( wxCommandEvent& event )
{
    if( m_pDR != NULL ) {
        if( g_pPathMan->GetpActivePath() == m_pDR ) g_pPathMan->DeactivatePath( m_pDR );
        
        if( !g_pPathMan->DeletePath( m_pDR ) )
            return;
        if( g_pODPathPropDialog && ( g_pODPathPropDialog->IsShown()) && (m_pDR == g_pODPathPropDialog->GetPath()) ) {
            g_pODPathPropDialog->Hide();
        }
        
        if( g_pPathManagerDialog && g_pPathManagerDialog->IsShown() )
            g_pPathManagerDialog->UpdatePathListCtrl();
        
        if( g_pODPointPropDialog && g_pODPointPropDialog->IsShown() ) {
            g_pODPointPropDialog->ValidateMark();
            g_pODPointPropDialog->UpdateProperties();
        }
        
    }
    
    DR *l_pDR = new(DR);
    g_pDRList->Append( l_pDR );
    g_pPathList->Append( l_pDR );
    l_pDR->m_PathNameString << _("DR") << _T(" ") << g_pDRList->GetCount();
    
    ODPoint *beginPoint = new ODPoint( g_pfFix.Lat, g_pfFix.Lon, wxEmptyString, wxS("Start"), wxT("") );
    beginPoint->SetNameShown( false );
    beginPoint->SetTypeString( wxT("DR Point"));
    beginPoint->m_IconName = g_sDRPointIconName;
    beginPoint->m_bIsolatedMark = false;
    beginPoint->m_bShowODPointRangeRings = g_bDRPointShowRangeRings;
    beginPoint->m_iODPointRangeRingsNumber = g_iDRPointRangeRingsNumber;
    beginPoint->m_fODPointRangeRingsStep = g_fDRPointRangeRingsStep;
    beginPoint->m_iODPointRangeRingsStepUnits = g_iDRPointRangeRingsStepUnits;
    beginPoint->m_wxcODPointRangeRingsColour = g_colourDRPointRangeRingsColour;
    beginPoint->m_iRangeRingStyle = g_iDRPointRangeRingLineStyle;
    beginPoint->m_iRangeRingWidth = g_iDRPointRangeRingLineWidth;
    l_pDR->AddPoint( beginPoint, false );

    m_textCtrlSOG->GetValue().ToDouble( &l_pDR->m_dSoG );
    l_pDR->m_iCoG = g_ocpn_draw_pi->GetTrueOrMag( wxAtoi( m_textCtrlCOG->GetValue() ) );
    l_pDR->m_dMagCOG = g_dVar;
    m_textCtrlLength->GetValue().ToDouble( &l_pDR->m_dDRPathLength );
    m_textCtrlDRPointInterval->GetValue().ToDouble( &l_pDR->m_dDRPointInterval );
    
    l_pDR->m_iLengthType = m_radioBoxLengthType->GetSelection();
    l_pDR->m_iIntervalType = m_radioBoxIntervalType->GetSelection();
    l_pDR->m_iDistanceUnits = m_radioBoxDistanceUnits->GetSelection();
    l_pDR->m_iTimeUnits = m_radioBoxTimeUnits->GetSelection();
    
    switch ( m_radioBoxLengthType->GetSelection() ) {
        case ID_LT_TIME: {
            switch ( m_radioBoxTimeUnits->GetSelection() ) {
                case ID_TU_MINUTES:
                    l_pDR->m_dTotalLengthNM = ( l_pDR->m_dSoG / 60 ) * l_pDR->m_dDRPathLength;
                    break;
                case ID_TU_HOURS:
                    l_pDR->m_dTotalLengthNM = l_pDR->m_dSoG * l_pDR->m_dDRPathLength;
                    break;
                case ID_TU_DAYS:
                    l_pDR->m_dTotalLengthNM = ( l_pDR->m_dSoG * l_pDR->m_dDRPathLength ) * 24;
                    break;
            }
            break;
        }
        case ID_LT_DISTANCE: {
            if( m_radioBoxDistanceUnits->GetSelection() == ID_DU_KILOMETRES )
                l_pDR->m_dTotalLengthNM = l_pDR->m_dDRPathLength / 1.852;
            else
                l_pDR->m_dTotalLengthNM = l_pDR->m_dDRPathLength;
            break;
        }
    }
    
    switch ( m_radioBoxIntervalType->GetSelection() ) {
        case ID_IT_TIME: {
            switch ( m_radioBoxTimeUnits->GetSelection() ) {
                case ID_TU_MINUTES:
                    l_pDR->m_dDRPointIntervalNM = ( l_pDR->m_dSoG / 60 ) * l_pDR->m_dDRPointInterval;
                    break;
                case ID_TU_HOURS:
                    l_pDR->m_dDRPointIntervalNM = l_pDR->m_dSoG * l_pDR->m_dDRPointInterval;
                    break;
                case ID_TU_DAYS:
                    l_pDR->m_dDRPointIntervalNM = ( l_pDR->m_dSoG * l_pDR->m_dDRPointInterval ) * 24;
                    break;
            }
            break;
        }
        case ID_IT_DISTANCE: {
            if( m_radioBoxDistanceUnits->GetSelection() == ID_DU_KILOMETRES )
                l_pDR->m_dDRPointIntervalNM = l_pDR->m_dDRPointInterval / 1.852;
            else
                l_pDR->m_dDRPointIntervalNM = l_pDR->m_dDRPointInterval;
            break;
        }
    }
    
    double l_dStartLat = g_pfFix.Lat;
//.........这里部分代码省略.........