Enum ftml::tree::LinkType

pub enum LinkType {
    Direct,
    Page,
    Interwiki,
    Anchor,
    TableOfContents,
}

Variants

Direct

This URL was specified directly.

For instance, as a raw URL, or a single-bracket link.

Page

This URL was specified by specifying a particular Wikijump page.

This variant comes from triple-bracket links.

Interwiki

This URL was generated via interwiki substitution.

Anchor

This URL points to an anchor elsewhere on this page.

TableOfContents

This URL points to entries on a page in a table of contents.

Implementations

impl LinkType

pub fn name(self) -> &'static str

Examples found in repository

src/render/html/element/link.rs (line 57)

pub fn render_link(
    ctx: &mut HtmlContext,
    link: &LinkLocation,
    label: &LinkLabel,
    target: Option<AnchorTarget>,
    ltype: LinkType,
) {
    info!("Rendering link '{:?}' (type {})", link, ltype.name());
    let handle = ctx.handle();

    // Add to backlinks
    ctx.add_link(link);

    let url = normalize_link(link, ctx.handle());

    let target_value = match target {
        Some(target) => target.html_attr(),
        None => "",
    };

    let css_class = match link {
        LinkLocation::Url(url) if url == "javascript:;" => "wj-link-anchor",
        LinkLocation::Url(url) if url.starts_with('#') => "wj-link-anchor",
        LinkLocation::Url(url) if url.starts_with('/') => "wj-link-internal",
        LinkLocation::Url(_) => "wj-link-external",
        LinkLocation::Page(page) => {
            if ctx.page_exists(page) {
                "wj-link-internal"
            } else {
                "wj-link-internal wj-link-missing"
            }
        }
    };

    let interwiki_class = if ltype == LinkType::Interwiki {
        " wj-link-interwiki"
    } else {
        ""
    };

    let site = ctx.info().site.as_ref().to_string();
    let mut tag = ctx.html().a();
    tag.attr(attr!(
        "href" => &url,
        "target" => target_value; if target.is_some(),
        "class" => "wj-link " css_class interwiki_class,
        "data-link-type" => ltype.name(),
    ));

    // Add <a> internals, i.e. the link name
    handle.get_link_label(&site, link, label, |label| {
        tag.contents(label);
    });
}

Trait Implementations

impl Clone for LinkType

fn clone(&self) -> LinkType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LinkType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LinkType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for LinkType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for LinkType

type Iterator = LinkTypeIter

fn iter() -> LinkTypeIter

impl PartialEq<LinkType> for LinkType

fn eq(&self, other: &LinkType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LinkType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<&'a str> for LinkType

type Error = &'a str

The type returned in the event of a conversion error.

fn try_from(value: &'a str) -> Result<LinkType, &'a str>

Performs the conversion.

impl Copy for LinkType

impl Eq for LinkType

impl StructuralEq for LinkType

impl StructuralPartialEq for LinkType