Custom Chart Types

wxString MyCustomChart::GetFileSearchMask(void) {
    return "*.mchart";  // Custom chart file extension
}

int MyCustomChart::Init(const wxString &full_path, int init_flags) {
    // Store the path
    m_full_path = full_path;

    // Check init flags to determine how much to load
    if (init_flags == PI_HEADER_ONLY) {
        // Load only chart metadata (for chart database)
        if (!LoadChartHeader(full_path)) {
            return INIT_FAIL_REMOVE;  // Failed to load chart header
        }
    } else {
        // Load full chart data
        if (!LoadFullChart(full_path)) {
            return INIT_FAIL_REMOVE;  // Failed to load chart
        }
    }

    // Initialize chart properties
    m_Chart_Scale = 50000;  // Example scale 1:50000
    m_Chart_Skew = 0.0;     // No skew
    m_projection = PI_PROJECTION_MERCATOR;  // Mercator projection

    // Set basic metadata
    m_FullPath = full_path;
    m_Name = GetChartTitle();
    m_Description = GetChartDescription();
    m_ID = GetChartID();
    m_DepthUnits = "Meters";
    m_SoundingsDatum = "MLLW";
    m_datum_str = "WGS84";
    m_SE = "1.0";
    m_EdDate = wxDateTime::Now();

    // Mark as ready to render
    m_bReadyToRender = true;

    return INIT_OK;
}

void MyCustomChart::SetColorScheme(int cs, bool bApplyImmediate) {
    // Store the color scheme
    m_ColorScheme = cs;

    // Apply color scheme to chart elements
    UpdateChartColors(cs);

    // If immediate application requested, invalidate any cached rendering
    if (bApplyImmediate) {
        m_rendered_chart = wxBitmap();  // Clear cached rendering
    }
}

bool MyCustomChart::GetChartExtent(ExtentPI *pext) {
    if (!pext)
        return false;

    // Fill in the extent structure with chart boundaries
    pext->NLAT = m_max_lat;  // Northern boundary
    pext->SLAT = m_min_lat;  // Southern boundary
    pext->ELON = m_max_lon;  // Eastern boundary
    pext->WLON = m_min_lon;  // Western boundary

    return true;
}

wxBitmap &MyCustomChart::RenderRegionView(const PlugIn_ViewPort &VPoint, const wxRegion &Region) {
    // Check if we have a cached rendering that's still valid
    if (m_rendered_chart.IsOk() &&
        m_last_vp_scale == VPoint.view_scale_ppm &&
        m_last_vp_rotation == VPoint.rotation &&
        m_last_vp.Contains(VPoint.clat, VPoint.clon)) {
        // Return cached bitmap if viewport hasn't changed significantly
        return m_rendered_chart;
    }

    // Create a new bitmap for rendering
    m_rendered_chart = wxBitmap(VPoint.pix_width, VPoint.pix_height);

    // Create memory DC for drawing
    wxMemoryDC dc;
    dc.SelectObject(m_rendered_chart);

    // Clear the background
    dc.SetBackground(wxBrush(GetBackgroundColor()));
    dc.Clear();

    // Set up drawing parameters
    dc.SetFont(GetChartFont());

    // For each chart element...
    // 1. Convert from geographic to screen coordinates
    // 2. Check if it's in the visible region
    // 3. Draw it with appropriate style

    // Example: Draw land areas
    dc.SetPen(wxPen(GetLandOutlineColor(), 1));
    dc.SetBrush(wxBrush(GetLandFillColor()));
    for (auto &landArea : m_land_areas) {
        // Convert polygon points from lat/lon to screen coords
        wxPoint *points = new wxPoint[landArea.size()];
        for (size_t i = 0; i < landArea.size(); i++) {
            GetCanvasPixLL(&VPoint, &points[i], landArea[i].lat, landArea[i].lon);
        }

        // Draw the polygon
        dc.DrawPolygon(landArea.size(), points);
        delete[] points;
    }

    // Draw depth contours
    dc.SetPen(wxPen(GetDepthColor(10), 1));  // 10m contour
    // ... similar drawing code for contours

    // Draw text labels
    dc.SetTextForeground(GetTextColor());
    for (auto &label : m_labels) {
        wxPoint pos;
        GetCanvasPixLL(&VPoint, &pos, label.lat, label.lon);
        dc.DrawText(label.text, pos);
    }

    // Clean up
    dc.SelectObject(wxNullBitmap);

    // Store viewport for cache validation
    m_last_vp = ViewPortRegion(VPoint);
    m_last_vp_scale = VPoint.view_scale_ppm;
    m_last_vp_rotation = VPoint.rotation;

    return m_rendered_chart;
}

double MyCustomChart::GetNormalScaleMin(double canvas_scale_factor, bool b_allow_overzoom) {
    // Return minimum scale factor (maximum zoom in)
    if (b_allow_overzoom)
        return 0.125;  // Allow up to 8x zoom
    else
        return 0.5;    // Allow up to 2x zoom
}

double MyCustomChart::GetNormalScaleMax(double canvas_scale_factor, int canvas_width) {
    // Return maximum scale factor (maximum zoom out)
    return 2.0;  // Allow 2x zoom out
}

double MyCustomChart::GetNearestPreferredScalePPM(double target_scale_ppm) {
    // If you have preferred scales, snap to the nearest one
    // For most charts, just return the requested scale
    return target_scale_ppm;
}

bool MyCustomChart::AdjustVP(PlugIn_ViewPort &vp_last, PlugIn_ViewPort &vp_proposed) {
    // Make any necessary adjustments to the proposed viewport
    // For example, constrain to chart boundaries

    // Most charts don't need special handling, so return false
    return false;
}

void MyCustomChart::GetValidCanvasRegion(const PlugIn_ViewPort &VPoint, wxRegion *pValidRegion) {
    // Define the region on screen where this chart has valid data

    // For rectangular charts, this is often the entire viewport
    pValidRegion->Clear();
    pValidRegion->Union(0, 0, VPoint.pix_width, VPoint.pix_height);

    // For charts with irregular boundaries, compute the actual valid region
    // by transforming coverage polygons to screen coordinates
}

wxBitmap *MyCustomChart::GetThumbnail(int tnx, int tny, int cs) {
    // Create a small bitmap for the thumbnail
    wxBitmap *thumbnail = new wxBitmap(tnx, tny);

    // Set up a memory DC
    wxMemoryDC dc;
    dc.SelectObject(*thumbnail);

    // Clear with background color
    wxColour backColor;
    if (cs == PI_GLOBAL_COLOR_SCHEME_DAY)
        backColor = wxColour(255, 255, 255);  // White for day
    else if (cs == PI_GLOBAL_COLOR_SCHEME_DUSK)
        backColor = wxColour(80, 80, 80);     // Dark gray for dusk
    else
        backColor = wxColour(30, 30, 30);     // Very dark gray for night

    dc.SetBackground(wxBrush(backColor));
    dc.Clear();

    // Set up a simplified viewport for thumbnail rendering
    PlugIn_ViewPort vp;
    vp.pix_width = tnx;
    vp.pix_height = tny;
    vp.clat = (m_max_lat + m_min_lat) / 2;  // Center latitude
    vp.clon = (m_max_lon + m_min_lon) / 2;  // Center longitude
    vp.rotation = 0;
    vp.skew = 0;

    // Calculate scale to fit chart in thumbnail
    double lat_range = m_max_lat - m_min_lat;
    double lon_range = m_max_lon - m_min_lon;
    double xscale = tnx / (lon_range * 60 * 1852);  // Lon degrees to pixels
    double yscale = tny / (lat_range * 60 * 1852);  // Lat degrees to pixels
    vp.view_scale_ppm = std::min(xscale, yscale);   // Use smaller scale to fit

    // Draw simplified chart elements
    // ... similar to RenderRegionView but with less detail

    // Clean up
    dc.SelectObject(wxNullBitmap);

    return thumbnail;
}