Advanced Map - WordPress Plugin

Advanced Map Setup and Usage Guide

Advanced Map is not meant to simply add another map to Modern Events Calendar. Its main job is to turn address-based events into clear geographic search: visitors see a map, an event list, address-based filters, and can quickly narrow results down to a specific city, district, street, category, organizer, or status.

In this guide, we will walk through the practical workflow: what to check before installation, how to prepare events and locations, where the map gets its data, which settings matter after enabling the add-on, how to build a useful page with Side Style, how to verify the result on the site, and where to look if the map, filters, or markers do not behave as expected.

This guide is written for a site owner, event editor, or WordPress administrator who already uses Modern Events Calendar and wants to make the event page more convenient for local events, conferences, branches, meetups, city programs, or venues with multiple addresses. We will not repeat the product's marketing copy. Instead, we will focus on how it works in practice and how to verify the result safely.

What an Event Map Helps You Do

A regular calendar answers the question "when does the event happen?" A map answers a different question: "where is it, and what is nearby?" That matters most when visitors are choosing not just a webinar from a list, but a real place: a venue, restaurant, campus, park, store, office, exhibition space, or a set of locations across different districts.

Advanced Map extends mapping inside the MEC ecosystem through a dedicated view. On the official Webnus page, the add-on is described as a tool that can create a professional shortcode for Map view, offers two popular styles, supports OpenStreetMap instead of Google Maps, adds filtering by address fields, and displays filters alongside events next to the map. The demo confirms the core idea: in Side Style, users see not only markers, but also a selection panel for State, City, Region, Street, Postal Code, Category, Location, Organizer, and Label.

In practice, this changes the structure of the page. Instead of a long list where every event competes for attention, the user starts by choosing a geographic context. For example, a visitor can first leave only events in a specific city, then choose a district, and only after that move to a category or organizer. If the site has many recurring meetups, public lectures, sports classes, or city events, that flow is often faster than a standard calendar.

When a map is more useful than a classic list

A map adds more value when the location influences the visitor's decision. For online events, it is rarely necessary unless you are showing a network of offline venues. For a small site with two events, a map may be excessive. But if you have multiple cities, branches, halls, districts, routes, or organizers, geographic filtering stops being a visual extra and becomes a way to shorten the path to the right event.

Typical use cases:

• A city portal shows events by district, street, and venue.
• An educational project lists classes across different buildings or campuses.
• A chain of restaurants, clubs, or stores publishes workshops tied to branch addresses.
• A conference uses the map to show sessions, booths, and meetups across multiple venues.
• A community accepts events through Frontend Event Submission and wants contributors to enter precise addresses.

In each of these cases, the map should work as a decision-making interface. Visitors do not need to know MEC's internal categories, shortcode IDs, or theme settings. They should see clear filters, markers, and an event list, then open the event page they need.

Who this product may not be a fit for

Advanced Map does not replace Modern Events Calendar itself. It is an add-on, not a standalone calendar, so it will not solve anything for a site that still lacks a proper event structure, categories, locations, and pages. It may also be unnecessary if the site publishes only online events, does not use addresses, or always shows a single fixed address.

Another important point is data quality. If editors fill in locations inconsistently, put the city into the street field, use different names for the same venue, or never verify coordinates, the map will not magically become smarter. It only visualizes what already exists in events and locations. That is why it makes sense to clean up your event database before configuring the add-on.

Practical takeaway: Advanced Map should be treated as a navigation layer on top of properly structured MEC events. If the data is sparse or chaotic, fix the events and locations first, then publish the map.

What to Check Before Installation

Before adding the add-on, do not just verify the plugin file. The map depends on several layers: WordPress, Modern Events Calendar, events, locations, shortcodes, the theme, caching, and the chosen map mode. If one layer is not ready, the issue on the public page may look like "Advanced Map is not working" even though the real cause is an empty location, a JavaScript conflict, or an incorrect shortcode.

Basic compatibility

The official page says the add-on requires MEC Pro. That is the first condition. If the site is running only an old lite version or the calendar is only partially installed, Advanced Map cannot be treated as an independent module. Make sure Modern Events Calendar Pro is installed and active, and that the calendar itself can already display events in its standard views.

Check the following:

• Modern Events Calendar Pro is active in the WordPress admin panel.
• Events open in the admin area and appear on the site in at least a standard list, grid, or calendar view.
• Events have a date, time, publication status, and at least one location if they are supposed to appear on the map.
• The site theme does not break standard MEC pages: the event page, shortcode page, and single event view should load without critical errors.
• The site does not have an active optimization rule that aggressively defers or combines all map, search, and filter scripts.

The last point is often underestimated. Optimization plugins may move JavaScript to the footer, delay libraries until the first click, combine scripts, or strip query parameters. That is usually harmless for plain text, but for maps and filters it can lead to an empty block, broken search, or a map that appears only after a manual page refresh.

Checking events and locations

In MEC, a location is not a decorative field. In its Event Modules documentation, Webnus explicitly explains that Location/Venue includes an address, coordinates, a website, a thumbnail, and can be reused across different events. Advanced Map follows the same logic, but makes address fields more important because filters and markers depend on them.

Before installing the add-on, select 5 to 10 real events and check them manually. Each event should have a clear venue, a consistent location name, and a detailed enough address. If the site operates across multiple cities, decide in advance how you will enter city, district, street, and ZIP code. User-facing filters are only helpful when values do not drift into dozens of variations because of typos.

Example of a poor data set: the same place appears as "City Hall," "city hall," "City hall park," "City Hall Park, NY," while some events put the address in the description instead of Location/Venue. Example of a clean data set: the location name is consistent, the address is stored in the address field, coordinates are verified, and additional locations are used only when the event truly takes place in multiple spots.

Map mode and expectations

The standard MEC map module relies on the Google Maps API. Webnus documentation explicitly states that Google Maps requires an API key, Maps JavaScript API, and, when working with coordinates, the Geocoding API. The same page also says that if you want to use OpenStreetMap instead of Google Maps, you should use the Advanced Map add-on. That does not mean every site can just flip one checkbox and skip verification. You need to understand which mode you want and what the theme or other plugins are already using.

If the site has been using Google Maps for a long time, check exactly where the API is loaded. MEC documentation warns that the site should not load multiple conflicting Google API keys from the theme, MEC, and third-party plugins. If you switch to OpenStreetMap through Advanced Map, test the public page separately in a clean browser, on a mobile device, and again after enabling cache.

Installation and Initial Verification

Installing Advanced Map is similar to installing other MEC add-ons. Webnus documentation for MEC describes two standard paths: upload the archive through the WordPress Dashboard, or extract it and send the folder to /wp-content/plugins/ via FTP. For most administrators, the safer option is the WordPress admin route because it involves less manual file system work.

Do not start configuring it directly on a live, high-traffic page. The safest order is a staging copy of the site or a private page first, then testing with a few events, and only then publishing it on a public page. If staging is not available, create a separate draft page and do not add it to the menu until testing is finished.

General activation order

1. Make sure MEC Pro is installed and already showing events in standard shortcodes or pages.
2. Install the add-on ZIP archive through Plugins > Add New > Upload Plugin, or via FTP if that is the standard process on your site.
3. Activate the add-on in the WordPress plugin list.
4. Open the MEC section where shortcodes are created and check whether a map view or Advanced Map settings are now available.
5. Create a test shortcode, choose a limited set of events, and place it on a private page.
6. Open the page in incognito mode and verify that the map, filters, and event list are visible without being logged into the admin area.

If you do not see the expected view or map settings after activation, do not jump straight to reinstalling WordPress. Check the obvious first: is MEC Pro active, is an old copy of MEC Lite still enabled, are two calendar versions conflicting, is there an admin error message, or did the add-on disable itself after upload?

A test page instead of a production rollout

A test page is not just about safety. It is also the easiest place to see what data actually reaches the map. Use a small sample of events: two cities, two categories, several locations, and one example with an additional location. That way, you are testing not only whether the map loads, but also whether filtering works.

For the first test, do not use every event on the site. If the map immediately shows hundreds of markers, it becomes harder to tell which setting caused which effect. Start with a limit, a category, or a date range. Once the core behavior is confirmed, expand the results.

How to tell the installation went well

A healthy initial result looks like this: the shortcode displays a map, events appear next to it or below it, filters react to user selection, markers match the events, and clicking lets users open the event page or a related interface element. The Advanced Map demo also shows Next, Prev, and My Position buttons, so when configuring Side Style, make sure the theme is not hiding those controls.

At this stage, do not judge the design by whether it looks perfect yet. Check the function first: the data is there, filters work, the map is not empty, and the mobile view does not break the primary workflow. Design and density can be refined once the mechanism is stable.

Locations, Addresses, and Coordinates

The most common mistake with event maps is starting with the map design when the real problem is in the data. The map does not know that "main hall," "hall A," and "City Hall" refer to the same address unless you manage locations carefully yourself. That is why Advanced Map configuration should begin with the data model: where the location is stored, which fields are required, who fills them in, and how the result is checked.

Location/Venue as the source of truth

In MEC, locations can be created separately and reused across events. That is better than manually entering the address inside every event. A standalone location helps avoid duplicates, store coordinates, and maintain the venue description and thumbnail. If one space regularly hosts events, create it once and assign it to events through Location/Venue.

For a site that uses a map, it helps to agree on a few simple rules:

• The location name should be human-readable and stable: do not change it for every event.
• The address should be precise enough for both the map and the visitor to understand the place.
• City, district, street, and ZIP code should be entered consistently if you use address-based filters.
• Coordinates should be verified manually for key venues, especially if the address is complex or inside a large complex.
• Additional locations should be used only for events that truly need them, otherwise users will see unnecessary points.

This discipline matters especially for Side Style. The demo shows filters not just for category and organizer, but also for State, City, Region, Street, and Postal Code. If editors fill those fields inconsistently, the filter panel turns into a long list of near-duplicate values.

Coordinates vs. address: which matters more

The address is convenient for the editor and the visitor. Coordinates are convenient for the map. MEC documentation notes that latitude and longitude can be filled automatically when using the Google Map module, and can also be entered manually. For Advanced Map, that matters as a general principle: if the address is not recognized correctly, the marker may appear somewhere other than where users expect it.

For important events, do not validate coordinates formally - validate them by result. Open the public page, find the event through a filter, zoom in on the map, and compare the location to the real venue. If the marker lands on a neighboring building or in the city center, correct the location data and refresh the page after clearing cache.

Additional locations

The official Advanced Map page says the add-on can display other event locations on the single event page. MEC documentation also includes an Additional Locations setting under Event Modules > Locations, which adds the ability to select other venues in the event page. This is useful for a festival, exhibition, tour, route, or conference where one event is tied to multiple venues.

Do not use additional locations as a way to store "similar places" or backup addresses. On the map, that can create unnecessary noise. If visitors see multiple markers, they should understand why those points belong to the same event: different days, different halls, the start and end of a route, or branches of the same program.

Result check: open an event with an additional location, confirm that both the main and additional venue appear where expected, then check how that event shows up inside the map shortcode.

The Map Shortcode and Page Structure

Advanced Map is displayed through a shortcode within the Modern Events Calendar workflow. That is convenient because you can create a dedicated map page, keep the regular calendar on another page, and avoid disrupting the site's overall architecture. MEC documentation for advanced shortcodes points to M.E. Calendar > Shortcode > Add Shortcode and describes settings for skin, style, start date, limit, filters, geolocation, and other parameters.

How to choose the page's purpose

Before creating the shortcode, decide what the page is for. There is no single perfect map for every use case. A city portal needs wide filters and support for many venues. An education center may care more about clear separation by category and campus. A conference may only need a map with nearby events and a clear path to the event page.

Define the goal in one sentence. For example: "The user should be able to find the nearest offline event in their district and open its event page." Or: "The editor should be able to display a map of all conference venues with filters for category and organizer." That goal will help you choose the limit, the filter set, and the map's placement on the page.

What to configure in the shortcode first

Start with the smallest useful set. Too many filters in the first version overload the page and make troubleshooting harder. For testing, it is enough to choose the map, style, start date, limit, category, or event set, then verify the result. After that, you can add address-based filters, geolocation, map on top, or additional taxonomies.

When configuring the shortcode, pay attention to four parameter groups:

• Event selection. Start date, maximum date, limit, categories, locations, organizers, and statuses determine which events appear at all.
• Map display. Map skin/style, Side Style, map position, zoom, cluster markers, and navigation buttons determine how easy the result is to read.
• Filters. Address fields, categories, locations, organizers, and labels help users narrow the list, but they require clean data.
• Page behavior. Geolocation, mouse wheel zoom, next/previous navigation, script loading, and cache affect both usability and stability.

Do not enable everything at once. After each meaningful change, update the shortcode, clear the page cache, and test the public result in a new window. That process may seem slower, but it saves time if the map suddenly stops reacting to filters five minutes later.

Where to place the map on the page

If the map is the main search interface, place it immediately after the page's brief introductory text. If the map complements the calendar, you can show upcoming events first and place the full venue map below. On mobile devices especially, the user should quickly understand where the filters are, where the map is, and where to look for the results list.

Do not place Advanced Map inside a narrow sidebar column. A map with filters needs horizontal space and a clear interaction area. If the theme constrains content to a narrow width, it is better to create a wide page template or disable the sidebar for that page.

Side Style and Address-Based Filters

Side Style is the most prominent Advanced Map scenario. In the Webnus demo, the map works next to a filter panel and event list. Visitors see the geographic view and can simultaneously choose State, City, Region, Street, Postal Code, Category, Location, Organizer, and Label. This is not just a stack of dropdowns. It is an interface where the address structure itself becomes navigation.

How not to overload the filters

The temptation to enable everything at once is understandable: if the add-on supports more filters, it is easy to want all of them on the page. But users do not always need every address level. If events only happen in one city, the State filter may be unnecessary. If there are few addresses, Postal Code may only take up space. If categories already separate events well, keep address fields only at the levels where users actually need a choice.

A practical approach:

1. Start by enabling the filters that match a real user decision: city, district, category, or venue.
2. See how many unique values appear in each filter.
3. Remove fields where the same value repeats for almost every event.
4. Keep more detailed fields for pages with a larger number of events or for dedicated sections of the site.
5. Check the mobile view: the filter should remain manageable, not turn into a long wall of controls.

The best Advanced Map settings for an initial launch are usually not the most feature-heavy ones, but the clearest ones: one high-level geographic filter, one topical category, locations or organizers, plus a map with a readable zoom level.

State, City, Region, Street, and Postal Code

These filters are especially useful for large catalogs. But they require editorial discipline. If one event is entered as New York, another as NYC, and a third as New York City, the City filter will look messy. The same applies to Region and Street: users should not have to guess which version to choose.

Create a short internal guideline for editors. It only needs to explain how to enter city, district, street, and ZIP code, how to verify coordinates, and what to do with events that do not have a precise address. This matters even more on sites that use FES, because outside contributors enter the data.

Categories, locations, organizers, and labels

Address-based filters answer "where." Categories, locations, organizers, and labels answer "what," "who," and "in what status." The Advanced Map demo shows these filters living side by side. That is a strong combination if you do not overdo the quantity.

For example, city events might use City, Region, Category, and Label. A conference might use Location, Organizer, and Category. A network of training centers might use City, Location, and Organizer. If there are too many filters, the user ends up serving the interface instead of finding an event.

OpenStreetMap, Google Maps, and Map Modes

Advanced Map is especially interesting because it is officially positioned as a way to use OpenStreetMap instead of Google Maps in MEC maps. That matters for sites where the Google Maps API creates organizational overhead, where a different visual map base is preferred, or where the site owner wants to reduce dependence on Google Maps. At the same time, the article should not promise more than the sources confirm: the exact implementation, external requests, and behavior on your site depend on the MEC version, the add-on, the theme, and the settings.

When to choose OpenStreetMap

OpenStreetMap is worth considering if you need an event map with many points, do not want to build the interface around the Google Maps API, have regional events and good OSM coverage in your area, or already use OSM in other parts of the site. The official Advanced Map page says you can use OpenStreetMap without limits instead of Google Maps, but on a production site you still need to verify speed, tile rendering, and filter behavior.

For editors, the main difference is not the map brand but how you verify the result. After switching modes, open the map page and check markers, zoom, clustering, navigation buttons, mouse wheel behavior, and mobile pinch zoom. If you have events outside major cities, verify those separately.

When to stay with Google Maps

If the site already uses Google Maps reliably, addresses are recognized correctly, the API key is configured, and users are used to that map style, switching to another mode is not mandatory. Google Maps may also be more familiar to teams that actively use address autocomplete and other Google tools.

But when working with Google Maps, pay close attention to API conflicts. MEC documentation explicitly recommends checking whether another Google API key is loaded by plugins, the theme, or site settings. If the key is loaded twice, the symptoms may vary: the map does not appear, autocomplete fails, the browser console shows errors, and disabling one plugin suddenly fixes everything.

Zoom, clustering, and map controls

Advanced Map advertises zoom level settings for single event maps and shortcodes, mouse wheel zoom, cluster markers, and a default location. These parameters shape the first impression of the page. If the zoom is too broad, users see the whole country instead of the district. If it is too close, some events may seem to disappear. If there are many markers and clustering is off, the map turns into visual noise.

For a site with several venues in one city, start with a zoom level where the main districts are visible. For a regional map, use a wider zoom and clustering. For a single event page, location precision matters more, so you can zoom in closer. After changing the zoom, always test the mobile view: the map should not hijack page scrolling so aggressively that users cannot continue down the page.

User-Submitted Events and FES Address Fields

Advanced Map is especially useful for projects where events are not created only by the administrator. The official add-on page mentions address fields in the FES Form: users can enter precise addresses in the frontend submission form. MEC documentation for Frontend Event Submission confirms that FES settings can control form sections, required fields, and access through WordPress roles.

Why FES needs stricter rules

When events are created by your editorial team, you can agree on rules informally. When the form is filled out by organizers, partners, or visitors, mistakes become systematic: incomplete addresses, different versions of the city name, missing venue data, extra text in the street field, or an incorrect ZIP code. For a map, that is critical.

If you use FES together with Advanced Map, do three things. First, keep only the fields that are actually needed for the map and moderation. Second, make important address fields required wherever that is both possible and appropriate. Third, add an editorial review before the event is published. Even if the user sees the form on a public page, the map should receive clean data.

Roles, moderation, and security

MEC documentation emphasizes that FES relies on WordPress roles and capabilities. That means access to creating and editing events should not be handed out casually. If a user can publish an event immediately, they potentially affect the map, event list, and public navigation.

A safe workflow for an event catalog looks like this:

• Guests or outside contributors submit events for moderation, if the business process allows it.
• An editor reviews the title, date, category, location, address, and coordinates.
• The event is published only after the public result is checked on the map.
• Permissions for repeat contributors can be expanded gradually, but not until their typical mistakes are well understood.

This approach protects the map from junk data. Advanced Map can present your event structure beautifully, but it should not become a public showcase for unverified addresses.

Practical Example: A District-Based Event Page

Imagine the site of a city cultural center. It hosts lectures, exhibitions, and meetups across different districts. The goal is to create a page where visitors can quickly find an event by district and type, see it on the map, choose a marker or a row in the list, and open the event page. This is a typical Advanced Map scenario because the date matters, but the distance and location often matter more.

Goal

You need a "Nearby Events" page where the map shows published offline events, filters let users choose city, district, category, and organizer, and the list next to the map updates based on the selected values. The page should work on desktop and smartphone, should not break scrolling, and should not show events without locations.

Preparation

Before configuring the shortcode, prepare a test group of events. Create or select at least six events: two cities or districts, three categories, several locations, one organizer, and one label used as a status marker. For each event, verify Location/Venue, the address, and the coordinates. If an event takes place in multiple locations, enable Additional Locations only for that event.

Then decide which filters will be visible. For this scenario, City, Region, Category, and Organizer are enough. It is better to leave Street and Postal Code disabled for the first launch unless users actually need to search by street or ZIP code.

Configuration steps

1. Open M.E. Calendar > Shortcode > Add Shortcode.
2. Select map view or the available Advanced Map option that matches the installed add-on.
3. Choose Side Style if you want a layout with the map, filters, and events side by side.
4. Limit the test output by category or count so that every point on the map is easy to verify.
5. Enable the needed filters: city, district, category, and organizer.
6. Set the zoom so that all test districts are visible in the first screen without making the map feel too far away.
7. Insert the shortcode on a private page and save it.
8. Open the page in a new window, select each filter one by one, and compare the result to the test event list.

Verification

After configuration, verify the full chain from input data to output. Select a specific district, review the event list, click an event, return to the map, choose a category, then choose an organizer. If the map shows no results after a filter is selected, check whether the test set actually contains events with that combination of values. Sometimes the filter is working correctly, but there is simply no data for that combination.

Check the mobile view separately. In Side Style, the map and filters may be rearranged. The user should understand that they choose a filter first and then see the result. If the map takes over the entire screen and the list ends up too far below, change the order of blocks on the page, reduce the number of filters, or use a different page template.

One important nuance

The most frustrating issue in this scenario is the false impression of an empty map. For example, the City filter is selected, but Region is still set to a value that does not belong to that city. The user sees an empty list and assumes there are no events. If the site relies on many dependent filters, add a short explanation on the page or configure the filter set so the top-level filter does not conflict with lower-level ones.

Checking the Result After Configuration

A map should be considered configured not when the shortcode is placed on the page, but when you have tested real user actions. That is especially important with Advanced Map because the same screen combines the map, list, filters, markers, locations, events, and external scripts.

Admin review

Start by checking the technical basics:

• The page opens without a critical WordPress error.
• The map loads without an endless preloader.
• Markers match the events that are supposed to appear in the results.
• Filters update the list and the map instead of simply redrawing the page without results.
• Clicking an event or marker opens the expected event page.
• After clearing cache, the result does not change unexpectedly.

Then open the browser console. You do not need to be a developer to notice a serious problem. If you see repeated errors from the map library, API, theme scripts, or shortcode logic, save a screenshot and temporarily disable JavaScript optimization on the test page.

Editor review

The editor should confirm that the data makes sense to a human reader. Open 10 events from the map and check the titles, addresses, categories, organizers, status, and image. If one event looks out of place, correct the data in the event or location entry. Do not try to cover editorial mistakes with map settings.

A useful practice is to keep a short event publishing checklist:

• Date and time are filled in.
• The location is selected from existing entries or created according to the rules.
• The address and coordinates are verified.
• The category matches the user-facing filter.
• The organizer is selected if it is used in filtering.
• The event can be found on the test map after publication.

Visitor review

Ask someone who did not configure the site to complete a simple task: "Find the nearest event in the right district and open its event page." If they immediately understand where to choose the district and where to look for the result, the interface works. If they get lost between the map, list, and filters, the problem is not Advanced Map's feature set - it is the page structure.

This kind of test helps you remove unnecessary complexity. Sometimes you discover that the user only needs two filters and a sensible zoom level, while five extra fields only slow the choice down. An event map should save attention, not showcase every feature of the add-on at once.

Performance, Cache, and Mobile View

A map with filters is heavier than a regular text list. It loads scripts, styles, map data, markers, and events. On good hosting, that may not be noticeable, but on a crowded page the map quickly becomes a source of delays. That is why Advanced Map setup should end not only with visual verification, but also with a speed check.

What affects speed

Performance is affected by the number of events, the number of markers, clustering, page size, the theme, optimization plugins, external map requests, and the way the shortcode fetches data. The MEC changelog shows that the developers regularly fix the search bar, SQL queries, backend performance, and PHP notices. That means updates matter, but it also means you should avoid overloading a single page with the site's entire event archive.

If you have many events, use a limit, categories, a date range, or separate pages by region. Do not force the map to render everything that has ever been published. For the user, a fast relevant result is more valuable than a giant map filled with hundreds of old points.

Cache and JavaScript optimization

Caching plugins can speed up the page, but sometimes they break interactive elements. If filters stop working after cache is enabled, the map becomes empty, or markers appear only after a second refresh, temporarily disable script combining and deferred JavaScript loading for the map page. Then restore the rules one at a time.

Do not edit the add-on files. If you need to exclude a script from optimization, do it in the caching plugin settings or through documented tools provided by the theme or optimizer. Direct changes to the plugin core will be lost on update and may create new errors.

Mobile scenario

On a mobile device, a map can become awkward if it hijacks scrolling, takes up too much height, or pushes the event list below the first screen. Check the page on a real phone. Try selecting a filter, zooming the map, opening an event, going back, and changing the selection.

If the mobile experience is weak, reduce the map height, trim the filter set, move the intro text above the map, or add a short explanation before the shortcode. Do not overload the page with long instructions. It is better to make the interface clearer than to explain how users should work around its weaknesses.

Common Problems and Troubleshooting

Advanced Map troubleshooting should move from simple to complex. First check the event data and shortcode, then the map mode, then the theme, cache, and JavaScript. Do not start with a reinstall before confirming that the event actually has a location and matches the selected filters.

The map does not appear on the page

Symptom: the map area shows an empty block, endless loading, or only the event list with no map.

Possible causes: MEC Pro is not active, the add-on is not enabled, the wrong shortcode was selected, the theme hides the map container, JavaScript is conflicting, Google Maps API is not configured, or a required script is disabled. If you use Google Maps, check the key and make sure there is no second key in the theme or another plugin. If you use OpenStreetMap through Advanced Map, make sure the correct map mode is selected and that the page is not blocking external resources.

What to do: create a new test page with one simple shortcode, temporarily disable JavaScript minification for that page, check the browser console, then re-enable optimization gradually. If the simple page works, the issue is in the specific template or setting combination.

The event exists in the admin area but does not appear on the map

Symptom: the event is published, but it does not appear among the markers or in the Advanced Map list.

Check the date, publication status, selected categories, shortcode restrictions, location, address, and coordinates. If the shortcode only shows future events or a specific category, an event outside those conditions will not appear. If no location is assigned, the map cannot display a marker.

How to fix it: temporarily remove extra shortcode filters, set a small limit, pick an event with a clearly completed location, and test it by itself. Once it appears, restore restrictions one by one.

Filters return empty results

Symptom: after choosing a city, district, or category, the list disappears even though the site does have matching events.

Most often, the cause is either a filter combination or dirty data. For example, one City is selected, Region belongs to a different city, a category is missing from the event, or the same value is spelled in several ways. In Side Style, this is especially visible because address-based filters sit next to each other.

What to check: open the events that should match the selected combination and compare their field values. Standardize city, district, street, and ZIP code formatting. If the data set is small, remove overly detailed filters from the first screen.

Markers appear in the wrong place

Symptom: the event is found, but the marker points to a neighboring building, the city center, or some other odd location.

The cause is usually an incomplete address, incorrect coordinates, or an ambiguous venue name. For Google Maps, the relevant APIs also need to be enabled. MEC documentation specifically mentions latitude/longitude and the Geocoding API for coordinate handling.

How to fix it: open the location in the admin area, refine the address, verify coordinates with an external service, save the location, clear cache, and reopen the map. If the event uses Additional Locations, check each point separately.

The map breaks after cache is enabled

Symptom: everything worked before optimization, but after enabling cache the filters stop working, the map becomes empty, or the buttons stop responding.

The cause is often script combining, deferred loading, or script relocation. The map and filters depend on load order. If the optimizer changes that order, the interface can break.

What to do: exclude the map page or specific MEC/map scripts from aggressive optimization, clear both browser and site cache, and test in incognito mode. If the problem disappears after exclusion, keep the rule and document it in the site's technical notes.

Mobile device issues

Symptom: the user cannot scroll the page normally, filters are too long, the event list is hidden below the map, or the control buttons are too small.

The cause may be the selected style, map height, theme, or simply too many filters. Advanced Map provides the functionality, but mobile ergonomics depend on the page as a whole.

How to fix it: reduce the number of filters, test a different page template, lower the map height, remove unnecessary widgets next to the shortcode, and test several real tasks. If a mobile user cannot quickly find an event, the configuration needs to be simplified.

Useful Improvements Without Editing the Plugin

With Advanced Map, it is better to avoid code that interferes with how the map works. The add-on has its own logic, and specific hooks and CSS classes may change. If there is no recent official documentation for a particular hook or class, it is safer to rely on MEC, theme, and caching plugin settings rather than writing an arbitrary snippet.

What you can improve safely

The safest improvements usually do not require code:

• Create a dedicated page without a sidebar so the map has enough width.
• Limit the shortcode to current events, categories, or a region.
• Remove unnecessary filters if they do not help users choose.
• Use consistent rules for filling in locations.
• Exclude the map page from aggressive deferred JavaScript loading.
• Add a short intro before the map explaining how to choose a city or district.

If you need to change the appearance, use theme settings, the editor, or safe CSS in a child theme. But do not add CSS based on random classes from the inspector until you confirm those classes consistently belong to the right block. A selector that is too broad can break other MEC shortcodes.

An editorial checklist instead of complex code

For an event map, a short editorial checklist is more useful than a complex technical workaround. It can look like this:

Before publishing an event:
1. Select an existing Location/Venue or create a new one according to the rules.
2. Check the city, district, street, and ZIP code.
3. Verify coordinates for a new venue.
4. Assign a category and organizer.
5. Open the test map and confirm that the event can be found through a filter.

This is not site code - it is a workflow. It reduces errors more effectively than trying to fix messy addresses programmatically after publication.

Video About Advanced Map

The official Advanced Map page includes a Quick Tour button that links to a YouTube video about the product. It is useful as a quick visual overview: it helps you see how the map, Side Style, and filters feel in motion. Use the video as a complement to this guide, not as a substitute for testing on your own site.

After watching, return to the practical steps: prepare locations, create the shortcode, verify the filters, test the mobile view, and only then publish the map on a live page.

When Advanced Map Is the Right Choice

Advanced Map is worth using when the site already runs on Modern Events Calendar, events have real addresses, and visitors need to choose by location. In those conditions, the add-on adds more than just a map - it creates a full search interface with Side Style, address-based filters, markers, an event list, zoom controls, clustering, and a verifiable link between shortcode settings and the public result.

Before launch, verify the foundation: MEC Pro is active, events are fully filled out, locations are not duplicated, addresses and coordinates are clear, the shortcode shows a limited test set, filters are not overloaded, the mobile view does not interfere with scrolling, and cache is not breaking JavaScript. If that chain works, you can download the Advanced Map file and move on to implementing it on the live page.

The main selection criterion is simple: if the map helps visitors find the right event faster and reduces the workload on editors, the product makes sense. If the map is needed only as a decorative block, it is better to improve the event structure, categories, and standard MEC views first. A good map starts not with a beautiful marker, but with accurate data and a clear user scenario.