Override whether the reward levels feature is active. Default: true.
igcf_is_pwyw_with_rewards
$enabled
Override whether the “Pledge What You Want” option appears alongside reward tiers. Default: true.
igcf_reward_level_post_type_args
$args
Modify the reward level custom post type registration arguments.
igcf_reward_level_editable_fields
$fields, $campaign
Modify which reward level fields remain editable after a campaign leaves Draft status. $fields is an array of field names (e.g., title, description, image_id, active).
igcf_rest_prepare_reward_level
$response, $post, $request
Filter reward level data before it is returned in a REST response. $response is a WP_REST_Response.
Modify which campaign fields are locked for a given campaign and user. $fields is an array of field keys (e.g., title, goal, categories). Add-ons can selectively unlock fields — for example, allowing creators to edit descriptions on active campaigns.
Modify the arguments passed to the campaign form template.
igcf_campaign_form_state
$state, $campaign
Modify the form state (buttons, read-only flag, messages).
igcf_campaign_form_readonly_message
$message, $campaign
Change the message shown when the form is read-only.
igcf_campaign_form_placeholder_tags
$tags, $campaign
Customize the placeholder tag suggestions shown in the campaign form tag field when no tags are selected. $tags is an array of tag names (up to five most-used public tags by default). $campaign is the WP_Post being edited, or null in create mode. Useful for category-aware lists or add-on-driven suggestions.
igcf_campaign_form_submit_button
$button, $campaign_status
Filter the final-step submit button on draft and rejected campaigns. $button is an array { value, label, class }. Add-ons swap it (for example, Ignition Platform Mode relabels it “Submit for Review”); mutate value / label and preserve class.
igcf_determine_initial_status
$status, $request, $campaign_id
Override the computed initial status of a campaign submission. $request is the WP_REST_Request. Core’s default resolves a direct-mode preview / active status; add-ons route submissions to pending review instead.
Modify the custom post type registration arguments.
igcf_campaign_statuses
$statuses
Modify the registered custom post statuses. In a direct-mode core install the moderation statuses (igcf_pending_review, igcf_rejected) are not registered; Ignition Platform Mode hooks this filter to add them.
igcf_campaign_meta_fields
$meta_fields
Modify the meta field definitions.
igcf_is_moderation_enabled
$enabled
Whether campaign moderation is active. Core defaults it to false (direct mode has no review gate); Ignition Platform Mode filters it on when its moderation feature is enabled. Consumers read it via igcf_is_moderation_enabled().
Modify the campaign state machine. $transitions is an associative array of status => allowed_next_statuses[]. Core’s direct-mode machine is draft → preview/active → paused → ended → closed; add-ons register new statuses and edges here (for example, Ignition Platform Mode adds the pending-review and rejected moderation edges).
Control whether a campaign can be withdrawn from review.
igcf_campaign_detail_lifecycle_verbs
$verbs, $status, $flags, $campaign_id
Filter the ordered lifecycle-verb list on the wp-admin campaign detail actions bar. $verbs is a string[]; $flags is an array of per-campaign flags. Add-ons inject verbs core omits in direct mode (for example, Ignition Platform Mode adds Approve / Reject).
igcf_campaign_duplicate_meta_keys
$meta_keys, $post_id, $new_post_id
Control which meta keys are copied when duplicating.
igcf_campaign_duplicate_taxonomies
$taxonomies, $post_id, $new_post_id
Control which taxonomies are copied when duplicating.
Modify the columns in the admin campaign list table.
igcf_campaign_row_actions
$actions, $post
Modify row actions in the admin campaign list.
igcf_campaign_bulk_actions
$actions, $current_status
Modify available bulk actions by status.
igcf_admin_menu_badges
$badges, $mode
Modify admin menu badge counts. $mode is the resolved Live/Test view mode ('live' or 'test') — see below.
Badge counts and the Live/Test view mode.$mode tells a subscriber which view the
admin is currently looking at. If your count comes from campaign, pledge, or update data,
count only data belonging to that mode, so the bubble agrees with the screen it links to.
If it counts configuration instead (an unset setting, an inactive dependency), ignore
$mode.
Receiving $mode is opt-in: register with accepted_args of 2. Subscribers on the
default of 1 never see it and keep working unchanged.
Seams on the wp-admin pledge detail page, so an add-on that takes a share of a pledge can show its working where the operator reads the totals. There are two kinds. Settlement terms say where a charge went, and are documented below. Column filters add descriptive columns to the Payment Attempts and Refunds tables further down the same page, and are listed here. Core owns ordering and escaping on both; a contribution that is not the documented shape is discarded rather than rendered, so a misbehaving listener degrades to core’s own figures instead of breaking the page.
Filter
Parameters
Description
igcf_pledge_detail_attempt_columns
$columns, $pledge
Add columns to the Payment Attempts table.
igcf_pledge_detail_attempt_cells
$cells, $attempt, $pledge
Supply this attempt’s values for those columns, keyed to match.
igcf_pledge_detail_refund_columns
$columns, $pledge
Add columns to the Refunds table.
igcf_pledge_detail_refund_cells
$cells, $refund, $attempt, $pledge
Supply this refund’s values for those columns, keyed to match.
igcf_pledge_settlement_terms answers the other half of the money question on the pledge detail page: not what the charge was made of (that is igcf_pledge_breakdown_components) but where the charge went. Core applies it once per succeeded payment attempt, seeding its own Returned to backer term first and appending Net afterwards as the residual.
Filter
Parameters
Description
igcf_pledge_settlement_terms
$terms, $attempt, $pledge
Declare one settlement term per destination your add-on owns. $attempt is an Igcf_Payment_Attempt and $pledge an Igcf_Pledge — there is no context array, because every settlement figure is already keyed by attempt ID. Read the attempt you are handed; a pledge can carry more than one and core renders a block for each.
A term is:
array(
'key'=>string, // sanitize_key()'d, unique. First writer of a key wins.
// 'returned' and 'net' are reserved for core.
'label'=>string, // Plain text, in YOUR add-on's text domain. Core escapes it.
Core owns ordering, signs, totalling, the destination wording, escaping, its own two terms and both arithmetic checks. There is deliberately no sign field and no way to choose a position: core sorts by order then key and derives the sign from destination and state. Recommended weights are processing 200, commission 300 and tip 400; returned (100) and net (900) belong to core.
Declare a term whenever your add-on holds a record for this attempt, whatever the amount — a fully reversed commission is 'amount' => 0, 'state' => 'reversed' and renders as $0.00. Declare nothing when there is no record, and no row appears. Those are different facts, so resolve presence and amount from two different reads.
Malformed input degrades rather than breaking the page: a callback returning a non-array leaves core’s own terms standing, and a term that is not an array, carries a non-scalar key/label/destination, claims a value outside either enum, repeats a key, uses a reserved key, or carries a negative or non-integer amount is dropped whole. Every drop other than plain malformation also fires _doing_it_wrong(), visible under WP_DEBUG.
add_filter(
'igcf_pledge_settlement_terms',
// Do not type-hint $terms. A callback at a lower priority that forgets its
// return hands you null, and `array $terms` turns that into a TypeError that
// takes the whole admin pledge page down. Check the type instead.
Register the callback behind an is_admin() check: the statement exists on one wp-admin screen, so a globally registered callback runs its queries on every checkout and receipt render for no output.
The pledge, payment-attempt, and refund entities each expose the same three-filter shape (status registry, transitions map, and a pre-transition gate), plus a creation gate and a query-args filter. See the Service Layer for the data model.
Fires before a payment attempt is created. Return WP_Error to block.
igcf_payment_attempt_query_args
$args
Modify query arguments passed to Igcf_Payment_Attempt_Service::query().
igcf_payment_attempt_statuses
$statuses
Default: pending, succeeded, failed.
igcf_payment_attempt_transitions
$transitions
Default: pending → [succeeded, failed].
igcf_payment_attempt_before_{$new_status}
$pre, $attempt_id, $actor_id
Pre-transition gate. Return WP_Error to block.
igcf_payment_attempt_failure_codes
$codes
The registry of valid failure codes (card_declined, insufficient_funds, expired_card, processing_error, network_error, authorization_expired, campaign_failed, payment_abandoned, pledge_canceled). Core stamps pledge_canceled on every still-open attempt when its pledge is cancelled.
Modify query arguments passed to Igcf_Refund_Service::query().
igcf_refund_statuses
$statuses
Default: pending, succeeded, failed.
igcf_refund_transitions
$transitions
Default: pending → [succeeded, failed].
igcf_refund_before_{$new_status}
$pre, $refund_id, $actor_id
Pre-transition gate. Return WP_Error to block.
igcf_refund_reasons
$reasons
The registry of valid refund reasons (requested_by_customer, duplicate, fraudulent, campaign_failed, dispute_lost, goodwill, chain_reorg).
igcf_refund_failure_codes
$codes
The registry of refund failure codes (code => label) shown against a failed refund. Ships empty from core — core writes no refund failure code of its own; gateway add-ons add theirs. Mirrors igcf_payment_attempt_failure_codes.
Two WP_Error codes were added in 0.22.0, both raised before any row is written:
igcf_payment_attempt_not_refundable — the target attempt has not succeeded. A refund carrying a gateway_reference is admitted anyway and flagged with a note in the audit log, because a gateway reporting a refund means real money moved and refusing it would destroy the only record of it.
igcf_refund_partial_not_attributable — a partial refund with no gateway_reference, against an attempt charged more than its pledge. Core cannot say which of those minor units were pledge money and which were voluntary additions, so it declines rather than guess. Refund in full, or anchor the refund with a gateway reference.
Igcf_Refund_Service::create() runs its budget check and insert inside a transaction. If it wrongly believes none is open it issues START TRANSACTION, which on MySQL implicitly commits whatever the caller had open — silently ending someone else’s transaction on a money path. These two filters decide what it believes.
Filter
Parameters
Default
Description
igcf_db_in_transaction
$in_transaction
null
Declare whether a transaction is already open on this connection. Return true before calling Igcf_Refund_Service::create() from inside your own transaction and it will use a savepoint, leaving yours intact; return false to declare none; return null (the default, meaning “no opinion”) to defer to the server. A declaration always wins — a caller that opened a transaction knows better than any probe. Read through Igcf_Refund_Service::in_transaction().
igcf_db_server_reports_transaction_state
$reports
true on MariaDB, false elsewhere
Whether the database server can answer for itself. MariaDB exposes @@in_transaction; MySQL has no equivalent, so core assumes nothing is open rather than guessing. Server flavour is detected once per request.
These filters give gateway and fee add-ons their composition points. Core defines the contracts; the fee/net filters below are documented seams that core does not consume itself (the Platform Fees and gateway add-ons apply them).
Filter
Parameters
Default
Description
igcf_pledge_amount_to_charge
$amount, $pledge
the pledge amount
The amount a payment attempt should charge. Fee Recovery raises this to add a backer-paid cover. Consumed by core on every attempt create.
igcf_payment_attempt_application_fee_components
$components, $attempt
empty array
The application fee broken into named parts, array<string,int> in minor units (e.g. [ 'commission' => 500, 'tip' => 100 ]). Each add-on contributes one distinct key — Platform Fees adds commission, Contributions adds tip (a callback returns e.g. $components['tip'] = 100;) — so callback priority is cosmetic. Core normalises on read (keys through sanitize_key(), values through max( 0, (int) )), and the sum equals the scalar igcf_payment_attempt_application_fee. Resolve it with Igcf_Payment_Attempt_Service::get_application_fee_components() rather than calling apply_filters() yourself.
igcf_payment_attempt_application_fee
$fee, $attempt
the sum of the named components above (0 when there are none)
The platform’s cut, in minor units, for gateway-aware charging. A callback must be additive — returning a bare literal clobbers every contributed component. Core clamps the result to max( 0, (int) ).
igcf_payment_attempt_settles_application_fee
$settles, $attempt
false
Whether a gateway will actually settle this attempt’s application fee at capture. Answered by a split-capable gateway add-on for the attempts it owns — it is a claim about the gateway, not about configuration. Platform Fees reads it to decide whether to contribute a commission and whether to record a charge row, so on an install with no split-capable gateway the default false keeps commission entirely inert. Resolve it with Igcf_Payment_Attempt_Service::settles_application_fee() rather than calling apply_filters() yourself.
igcf_projected_charge_context
$defaults, $context
settles_application_fee: false, components: []
The attempt-free, campaign-keyed sibling of the two filters above, so checkout can ask “what would a charge look like?” before any Igcf_Payment_Attempt row exists. $context carries campaign_id (int), pledge_amount (int, minor units), payment_method (string) and currency (string, ISO 4217). Returns array{settles_application_fee:bool, components:array<string,int>}. Priority is load-bearing here (unlike the components seam): a gateway add-on sets settles_application_fee first at a low priority, then Platform Fees (e.g. igcf-fees::project_commission) adds components['commission'] only when the share settles — settlement must resolve before commission is added. Resolve it with Igcf_Payment_Attempt_Service::projected_charge_context().
igcf_payment_attempt_processing_fee
$fee, $attempt
0
What the payment processor kept out of this attempt, in minor units. Exactly one gateway answers per attempt: a callback MUST check $attempt->payment_method first and return the incoming value untouched for an attempt that is not its own, or it will overwrite a foreign gateway’s figure. Core clamps to max( 0, (int) ) and consumes the result — it is subtracted from the igcf_payment_attempt_net_to_creator default below. Resolve it with Igcf_Payment_Attempt_Service::get_processing_fee().
igcf_payment_attempt_net_to_creator
$net, $attempt
the attempt amount minus the processing fee
The net to the creator after add-on cuts, for reporting. Per-attempt; for the per-pledge equivalent that display surfaces actually render through, use igcf_pledge_net_amounts below. Since 0.22.0 the result is no longer floored at zero and can be negative — a fully refunded card payment leaves it under zero because the processor keeps its fee. It is computed before refunds and is a display figure, not a payout basis.
igcf_pledge_net_amounts
$net, $ids
map of pledge id → gross − refunded
The per-pledge net-to-creator seam. $net is an array keyed by pledge ID; an absent key means no money flowed for that pledge, and listeners must preserve that (do not add keys). Applied in two places: the batch read Igcf_Pledge_Service::get_net_for_pledges() that list screens and exports use, and the single-pledge render read behind the wp-admin pledge detail page — so one deduction reaches every creator- and admin-facing net figure consistently. A listener must not floor its answer at zero: the surfaces that render it now show a signed figure. Not applied to backer-facing figures, which render the backer’s own gross − refunded.
igcf_pledge_processing_fees
$fees, $pledge_ids
empty array
The batched, per-pledge sibling of igcf_payment_attempt_processing_fee, so a reconciliation surface can show the fee beside the net rather than only their difference. $fees is a map of pledge ID → minor units; $pledge_ids is a sanitized list of positive IDs. Same one-answerer rule. Absence is not zero: a callback must not add a key for a pledge it has no settled figure for, because callers render an empty cell for an absent key and 0.00 for a present zero. Read by the wp-admin and creator pledge exports through Igcf_Pledge_Service::get_processing_fees_for_pledges().
igcf_payment_attempt_operator_custody
$custody, $pledge, $payment_method
! igcf_pledges_go_to_creator()
Whether the operator holds a new payment attempt’s money. Answered by the gateway or platform add-on that owns the payment method — check $payment_method first and return $custody untouched for methods you do not own. Applied exactly once, at attempt-create time, and stamped on the row; it is never re-derived on read, so answer from durable facts rather than a setting that could change later. Core casts the result to a definite bool.
igcf_payment_attempt_operator_still_holds
$still, $attempt
the custody stamp above
Whether the operator is holding this payment’s money right now. The stamp records that the operator was holding it, which never stops being true; this answers the current state, which stops being true once a payout covers the payment. An answerer MUST guard with $attempt instanceof Igcf_Payment_Attempt before using the second argument, so a one-argument dispatch degrades rather than fatals. Core reads it to decide whether the pledge statement’s Net row says owed or received. Resolve it with Igcf_Payment_Attempt_Service::operator_still_holds().
igcf_pledge_breakdown_components
$rows, $context
seeded with the canonical pledge row
The line-item rows behind a pledge’s money breakdown, produced by the Igcf_Pledge_Breakdown service. Contributors append rows shaped array{key:string, label:string, amount:int, order:int} (amount in integer minor units, never a formatted string); Contributions adds all three of its rows here — cover_commission (order 200), cover_processing (400) and tip (500) — through the one callback, on the projected branch and the recorded-attempt branch alike (e.g. igcf-contributions::contribute_components). $context carries source ('attempt' or 'projection'), campaign_id, pledge_id, pledge_amount, currency, and — when source is 'attempt' — the attempt object; a callback that only understands one branch should return $rows untouched for the other. Core owns the canonical pledge row: a filter may reorder or relabel it, but its amount is forced back to the authoritative pledge amount and the row is restored if a filter drops it, so the total is always pledge + Σ components.
igcf_refund_proportional_fee_reversal
$reversal, $refund
0
A proportional fee clawback computed by Platform Fees.
igcf_payment_methods
$map
offline + registered gateways
The registry of payment methods (id => label). Gateway add-ons register themselves here.
Modify the arguments passed to the checkout template.
igcf_checkout_pre_submission_error
$error, $post_data, $campaign_id
Refuse a checkout submission before anything is created. Fires after nonce verification and input sanitisation but before identity is resolved, so a refusal creates no pledge, no payment attempt and no guest WordPress account. $error defaults to null. $post_data is the raw $_POST array — callbacks must unslash and sanitize anything they read. $campaign_id is the campaign being pledged to. Return contract: a non-empty string halts the submission (core re-renders the review step with that string as an alert notice); a null, empty-string, or non-string return proceeds unchanged. Contributions uses it (e.g. igcf-contributions::refuse_stale_total) to refuse when the disclosed igcf_total_shown no longer matches the recomputed total.
igcf_checkout_payment_method
$payment_method, $post_data, $campaign_id
Filter the payment method gateway add-ons want to claim from the backer’s checkout POST. $payment_method is the sanitized value from $_POST['igcf_payment_method'] (when the field is absent Core defaults it to the first gateway available for the campaign). $post_data is the raw POST array (nonce-verified by Core before the filter runs). $campaign_id is the campaign being pledged to. Return the gateway id Core should record on the new pledge. A return that is not a registered gateway id is treated as “no opinion” and discarded in favour of the backer’s own submitted value; a registered id is a real claim. Whichever value wins must be available for the campaign (see campaign-aware availability) — if it is not, Core refuses the pledge and re-renders the checkout review step with a notice, rather than substituting a different method. See Registering a Payment Gateway.
igcf_checkout_identity_html
$default_html, $context
Wrap or fully replace the rendered identity section HTML on the pledge review step. The filtered string is echoed as-is — add-ons that mutate the markup own their own escaping (the default $default_html passed in is fully escaped). $context has the same shape as the igcf_checkout_identity_before action.
igcf_gateway_available_for_campaign
$available, $gateway_id, $campaign_id
Older yes/no form — use igcf_gateway_unavailable_reasons in new code. Fires only for an enabled gateway that has no reasons against it so far, with $available always true. Returning false removes the gateway from the campaign; returning true never adds one back. A gateway removed here is shown to administrators on the campaign’s page as hidden by another plugin, with no reason given. Checkout hides it and refuses a submission that asks for it rather than quietly substituting another (ADR-043).
igcf_pledge_requires_shipping
$default, $context
Override whether a pledge in a given context requires a shipping address. $default reflects the per-tier _igcf_requires_shipping meta. $context is an array carrying reward_level_id (int) and campaign_id (int). Useful for region- or add-on-driven overrides.
igcf_pledge_shipping_field_schema
$fields
Modify the shipping field schema. $fields is an array of field definitions; each entry has key (string), label (string), required (bool), and autocomplete (string). Return value falls back to the defaults if not an array.
igcf_pledge_shipping_address
$decoded, $pledge_id
Filter a decoded shipping address on read. $decoded is the JSON-decoded associative array keyed by schema field key. Useful for redaction or for layering on data from another source.
The list of reasons an enabled gateway is not offered on one campaign. It fires for every enabled gateway, including ones whose own get_unavailable_reasons() already returned reasons, so you can add yours alongside. A gateway is offered only when the final list is empty.
Each reason is an array with three string keys:
Key
Meaning
code
A stable identifier, prefixed with your add-on’s prefix.
message
One plain, translated sentence. It is escaped on output, so don’t pass HTML.
fix_url
An admin URL where an administrator can fix the problem, or ''.
Add a reason to hide a gateway at checkout and tell the administrator why: the reasons appear in the Payment methods row of the campaign detail page. You can hide a gateway but never put one back: if a gateway already had reasons, an empty list returned here is ignored. Malformed entries are dropped and each key is cast to a string.
Rewrite the destination of the dashboard’s logout link. The default value is home_url() with the igcf_logged_out=1 query arg appended (which triggers a one-shot post-logout flash notice on the next page). Return any URL to redirect elsewhere after logout.
Modify context-specific messages shown on the auth form (e.g., 'pledge' context). Add-ons can register additional context keys.
igcf_registration_role
$role, $context, $email
Override the role assigned to new users. $context is 'pledge' or empty. Core’s default is 'igcf_backer' (a direct-mode install has no campaign-creator role). Add-ons register their own callbacks at a later priority to apply KYC, approval gates, or alternate role logic — Ignition Platform Mode uses this seam to assign the campaign-creator role to organic sign-ups when public campaign creation is enabled.
igcf_can_create_campaign
$can, $user_id
Gate access to the campaign-creation form per-user. Returned value is (bool)-cast before branching, so malformed returns fail closed. Scoped to create mode only — editing existing campaigns is unaffected.
igcf_welcome_set_password_url
$set_password_url, $user, $key
Filter the set-password URL embedded in the branded welcome email. $user is a WP_User; $key is the reset key. Useful for tracking parameters or routing through a custom set-password surface.
Register, remove, or reorder sections in the dashboard Account tab. $sections is an associative array keyed by section ID; each entry has label (string) and template (string — resolved via igcf_get_template() relative to public/views/). Default sections: profile, email, password, notifications, privacy.
igcf_notification_categories
$categories
Register additional notification toggles for the Account → Notifications section. $categories is an associative array keyed by category ID; each entry requires label, description, group ('backer', 'creator' or 'admin'), and email_types (array of email IDs this toggle controls). The page shows each group only to people with the permission Igcf_Notification_Category_Registry::get_group_capabilities() maps it to (igcf_create_pledge, edit_igcf_campaigns, igcf_staff), and its save ignores switches from a group the person can’t see. Categories in any other group are not shown on that page and keep their stored state.
igcf_password_reset_url
$reset_url, $user, $key
Filter the password-reset URL embedded in the branded password-reset email. $user is a WP_User; $key is the reset key. Useful for appending tracking parameters or routing through a custom reset surface.
Declares which keys of a settings option an operator may change. Every key you don’t list stays administrator-only. Return the map with your entry added:
'group'=>'my_addon_settings_group', // The group you passed to register_setting().
'keys'=>array( 'notice_*', 'max_items' ),
'addon'=>'my-addon', // Your add-on's catalog slug.
);
return$map;
});
Entry key
Meaning
group
The settings group the option is registered in.
keys
Keys within the option an operator may change. A key ending in * matches by prefix: notice_* covers notice_text.
addon
The slug of the add-on that owns the option.
What a declaration does:
Opens the group’s save to operators. WordPress’s options.php normally asks for manage_options before saving a group. For a declared group it asks for igcf_manage_settings instead.
Guards the save. When someone who has igcf_manage_settings but not manage_options saves, every key not on your list keeps its stored value, even if a hand-crafted request sends a new one. An option registered in a declared group with no declaration of its own is kept whole. Administrators, scheduled jobs and the command line are not affected.
Shows your settings page to operators. An add-on whose entry lists at least one key appears on an operator’s Settings → Add-ons tab, and its settings sub-page opens for them. An add-on that declares nothing stays administrator-only.
The guard does the enforcing, so hiding a field is a matter of presentation. To decide whether to render a field, ask Igcf_Settings_Guard::can_edit( $option, $key ). Core declares its own operator keys in igcf_settings through this same filter, at priority 5. An entry that isn’t this shape is dropped. See Registering Add-on Settings.
The site-wide answer to “does a pledge go to the platform, or straight to the campaign’s creator?” Core returns false — a plain install collects centrally. Read it through the igcf_pledges_go_to_creator() wrapper rather than calling apply_filters() yourself.
igcf_pledge_routing_consequences
$consequences, $to_creator
empty array (nothing is lost)
This is the one seam every payment method consults, so an operator answers the question once instead of once per gateway. Ignition Platform Mode answers it from its Who Receives Pledges setting; without that add-on nothing overrides the false.
Gateways branch on it to decide which credentials to ask for and which to use. Core’s Offline method uses it to decide whether a single site-wide instructions field makes sense at all. If you write a gateway that can split a payment, gate that behaviour here:
if ( igcf_pledges_go_to_creator() ) {
// Register the marketplace credential fields, split at capture.
}
Prefer a predicate that also checks your own preconditions — the routing setting being on does not mean your add-on is installed and configured.
If your add-on stops working under one of the two routing choices, say so through igcf_pledge_routing_consequences so the operator is warned before they switch rather than after. Append through the igcf_pledge_routing_consequence() helper, never by hand: add-ons answer one after another, each handed the list built so far, and an add-on that returns something that is not a list would make the next add-on’s append a fatal error — taking the whole settings screen down, not just the broken add-on’s entry. Core’s own cast runs only after every add-on has had its turn, so it cannot prevent that. Pass strings already run through your own __(), since each add-on translates in its own text domain.
add_filter(
'igcf_pledge_routing_consequences',
function($consequences,$to_creator){
if(!$to_creator){
return$consequences;// Only the "pledges go to each creator" choice costs us anything.
}
return igcf_pledge_routing_consequence(
$consequences,
__('Platform commission','my-addon'),
__('commission is taken out of a payment the platform collects, and this choice sends payments straight to the creator','my-addon')
The registry of add-on settings pages, keyed by add-on slug with a render callback as the value. Add-ons register here to surface a settings page under Settings → Add-ons. See Registering Add-on Settings.
igcf_addon_settings_url
$urls
Absolute settings URLs keyed by add-on slug, for add-ons whose settings screen already lives somewhere else — a payment gateway’s own screen under the Payments tab, say. Use this instead of igcf_addon_settings when you do not want a second, near-empty page under Settings → Add-ons. The value must be an absolute http/https URL; a relative path or another scheme is dropped rather than rendered as a broken link. A callback registered for the same slug via igcf_addon_settings wins.
igcf_addons_catalog
$catalog
The curated catalog of add-ons shown on the Add-ons tab. Each entry is an array with slug, name, description, plugin_file, download_url, version, and optional hidden. Add-ons (or a remote source) can inject entries; a hidden entry stays registered for slug resolution but is omitted from the catalog listing.
The creator dashboard’s per-campaign export (one row per pledge) and the wp-admin Pledges screen’s two exports (per-pledge across campaigns, and aggregated per-backer with status pivot) each expose their own column-list and row filters.
Modify the column headers for the admin pledge CSV export (filter-aware, one row per pledge across campaigns).
igcf_admin_pledge_export_row
$row, $pledge, $backer, $campaign, $creator
Modify a single row in the admin pledge CSV export. $pledge is an Igcf_Pledge, $backer and $creator are WP_User or null, $campaign is a WP_Post or null.
Modify the column headers for the admin backer CSV export (aggregated per (backer, currency) with a per-status pivot).
igcf_admin_backer_export_row
$row, $agg, $backer
Modify a single row in the admin backer CSV export. $agg is a stdClass carrying the aggregated counts and totals returned by Igcf_Pledge_Service::query_backer_aggregates(); $backer is a WP_User or null if the user has been deleted.
igcf_pledge_backer_aggregates_args
$args
Modify the query args passed to Igcf_Pledge_Service::query_backer_aggregates().
These modify the frontend dashboard shell (nav, account, pledges) and the per-campaign management view that core renders.
Filter
Parameters
Description
igcf_dashboard_args
$args
Modify arguments passed to the dashboard template.
igcf_dashboard_detail_args
$args, $campaign_id
Modify arguments for the campaign detail view.
igcf_dashboard_detail_sections
$sections, $campaign_id
Modify sections in the campaign detail view.
igcf_dashboard_pledge_detail_args
$args, $pledge_id
Modify arguments for the pledge detail view in the dashboard.
igcf_dashboard_pledge_row_args
$row, $pledge
Modify one backer-dashboard pledge-list row’s template args — for example append link actions (an actions array of entries with url, label, and optional class) or override the status label. $pledge is the Igcf_Pledge model for that row (note the detail filter above passes the pledge ID instead).
igcf_dashboard_campaign_pledge_row_args
$row, $pledge
The creator-table counterpart to igcf_dashboard_pledge_row_args. Core leaves overflow_actions empty; an add-on may append entries shaped array( 'action' => string, 'label' => string ) to put per-row actions such as “Mark payment received” on a creator’s campaign-pledges table.
igcf_dashboard_subview_args
$args, $subview, $campaign_id
Modify arguments for any dashboard subview template.
Filter whether a user is confined to the frontend (blocked from wp-admin). $user is a WP_User. Core returns false for everyone by default; add-ons that register a frontend-only role (such as Ignition Platform Mode, whose campaign creators live entirely on the frontend) filter it to include their users.
igcf_creator_redirect_url
$url, $user_id
Change the redirect URL sent to a frontend-only user who lands on a wp-admin request.
Modify post type registration arguments for updates.
igcf_determine_update_status
$status, $campaign_id, $update_id
Override the status applied to a campaign update on submission. Default: 'publish' (direct mode publishes updates immediately). Add-ons route updates to pending — for example, Ignition Platform Mode sends them for review.
Modify the WP_Query arguments used by the Campaign Grid block before the query runs. $atts is the resolved block/shortcode attribute array.
igcf_campaign_featured_resolved_id
$resolved_id, $atts
Override the campaign post ID resolved by the Featured Campaign block. Runs after auto/manual resolution but before the hero renders — return 0 to suppress output.
Return false to suppress the bundled og:* meta tags on a single campaign permalink. Useful when a dedicated SEO plugin (Yoast, Rank Math, SEOPress, etc.) is already emitting its own social meta. Default: true.
Override whether the Better Sharing integration is available. Defaults to the result of function_exists( 'better_sharing_render' ). Useful as a kill-switch during incident response or to force-disable the integration in tests.
igcf_better_sharing_is_installed
$installed
Override whether the Better Sharing plugin is detected as installed. Drives the install-vs-activate state of the Sharing settings panel.
igcf_better_sharing_is_active
$active
Override whether the Better Sharing plugin is detected as active. Drives the activate-vs-ready state of the Sharing settings panel.
igcf_sharing_locations
$locations
Modify the Better Sharing location registry. $locations is keyed by slug; each entry is [ label, default_enabled, view_style ] where view_style is 'compact' or 'inline'. Add-ons can register new sharing surfaces here.
igcf_sharing_render_args
$render_args, $location, $campaign_id
Filter the args passed to better_sharing_render() for an Ignition sharing location. Useful for appending tracking parameters to the share URL, overriding the UI template, or customizing the email pre-fill per location.
