manuelcillero/pagetop
manuelcillero/pagetop
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

⬆️ [megamenu] Upgrade to SmartMenus 1.2.1

Browse source
This commit is contained in:
Manuel Cillero 2023-07-30 08:39:09 +02:00
parent 10b496af27
commit aed120f96d
13 changed files with 359 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

275
pagetop-megamenu/src/component.rs
View file

@ -1,275 +0,0 @@
use pagetop::prelude::*;
use pagetop_jquery::JQuery;
new_handle!(COMPONENT_MEGAMENUITEM);
type Label = OneComponent<L10n>;
type Content = OneComponent<L10n>;
#[derive(Default)]
pub enum MegaMenuItemType {
#[default]
Void,
Label(Label),
Link(Label, String),
LinkBlank(Label, String),
Html(Content),
Submenu(Label, MegaMenu),
Separator,
}
// MegaMenuItem.
#[rustfmt::skip]
#[derive(Default)]
pub struct MegaMenuItem {
weight : Weight,
renderable: Renderable,
item_type : MegaMenuItemType,
}
impl ComponentTrait for MegaMenuItem {
fn new() -> Self {
MegaMenuItem::default()
}
fn handle(&self) -> Handle {
COMPONENT_MEGAMENUITEM
}
fn weight(&self) -> Weight {
self.weight
}
fn is_renderable(&self, cx: &Context) -> bool {
(self.renderable.check)(cx)
}
fn prepare_component(&self, cx: &mut Context) -> PrepareMarkup {
match self.item_type() {
MegaMenuItemType::Void => PrepareMarkup::None,
MegaMenuItemType::Label(label) => PrepareMarkup::With(html! {
li class="label" { a href="#" { (label.prepare(cx)) } }
}),
MegaMenuItemType::Link(label, path) => PrepareMarkup::With(html! {
li class="link" { a href=(path) { (label.prepare(cx)) } }
}),
MegaMenuItemType::LinkBlank(label, path) => PrepareMarkup::With(html! {
li class="link_blank" {
a href=(path) target="_blank" { (label.prepare(cx)) }
}
}),
MegaMenuItemType::Html(content) => PrepareMarkup::With(html! {
li class="html" { (content.prepare(cx)) }
}),
MegaMenuItemType::Submenu(label, menu) => PrepareMarkup::With(html! {
li class="submenu" {
a href="#" { (label.prepare(cx)) }
ul {
(menu.items().prepare(cx))
}
}
}),
MegaMenuItemType::Separator => PrepareMarkup::With(html! {
li class="separator" { }
}),
}
}
}
impl MegaMenuItem {
pub fn label(label: L10n) -> Self {
MegaMenuItem {
item_type: MegaMenuItemType::Label(OneComponent::new_with(label)),
..Default::default()
}
}
pub fn link(label: L10n, path: &str) -> Self {
MegaMenuItem {
item_type: MegaMenuItemType::Link(OneComponent::new_with(label), path.to_owned()),
..Default::default()
}
}
pub fn link_blank(label: L10n, path: &str) -> Self {
MegaMenuItem {
item_type: MegaMenuItemType::LinkBlank(OneComponent::new_with(label), path.to_owned()),
..Default::default()
}
}
pub fn html(content: L10n) -> Self {
MegaMenuItem {
item_type: MegaMenuItemType::Html(OneComponent::new_with(content)),
..Default::default()
}
}
pub fn submenu(label: L10n, menu: MegaMenu) -> Self {
MegaMenuItem {
item_type: MegaMenuItemType::Submenu(OneComponent::new_with(label), menu),
..Default::default()
}
}
pub fn separator() -> Self {
MegaMenuItem {
item_type: MegaMenuItemType::Separator,
..Default::default()
}
}
// MegaMenuItem BUILDER.
#[fn_builder]
pub fn alter_weight(&mut self, value: Weight) -> &mut Self {
self.weight = value;
self
}
#[fn_builder]
pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self {
self.renderable.check = check;
self
}
// MegaMenuItem GETTERS.
pub fn item_type(&self) -> &MegaMenuItemType {
&self.item_type
}
}
// MegaMenu.
new_handle!(COMPONENT_MEGAMENU);
actions_for_component!(MegaMenu);
#[rustfmt::skip]
#[derive(Default)]
pub struct MegaMenu {
weight : Weight,
renderable: Renderable,
id : IdentifierValue,
classes : Classes,
items : PackComponents,
template : String,
}
impl ComponentTrait for MegaMenu {
fn new() -> Self {
MegaMenu::default().with_classes(ClassesOp::SetDefault, "sm sm-clean")
}
fn handle(&self) -> Handle {
COMPONENT_MEGAMENU
}
fn id(&self) -> Option<String> {
self.id.get()
}
fn weight(&self) -> Weight {
self.weight
}
fn is_renderable(&self, cx: &Context) -> bool {
(self.renderable.check)(cx)
}
fn before_prepare_component(&mut self, cx: &mut Context) {
run_actions_before_prepare_megamenu(self, cx);
}
fn prepare_component(&self, cx: &mut Context) -> PrepareMarkup {
cx.alter(ContextOp::AddStyleSheet(
StyleSheet::at("/megamenu/css/menu.css").with_version("1.1.1"),
))
.alter(ContextOp::AddStyleSheet(
StyleSheet::at("/megamenu/css/menu-clean.css").with_version("1.1.1"),
))
.alter(ContextOp::AddJavaScript(
JavaScript::at("/megamenu/js/menu.min.js").with_version("1.1.1"),
));
JQuery.enable_jquery(cx);
let id = cx.required_id::<MegaMenu>(self.id());
PrepareMarkup::With(html! {
ul id=(id) class=[self.classes().get()] {
(self.items().prepare(cx))
}
script type="text/javascript" defer {
"jQuery(function(){jQuery('#" (id) "').smartmenus({"
"hideTimeout: 0,"
"showTimeout: 80,"
"});});"
}
})
}
fn after_prepare_component(&mut self, cx: &mut Context) {
run_actions_after_prepare_megamenu(self, cx);
}
}
impl MegaMenu {
// MegaMenu BUILDER.
#[fn_builder]
pub fn alter_weight(&mut self, value: Weight) -> &mut Self {
self.weight = value;
self
}
#[fn_builder]
pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self {
self.renderable.check = check;
self
}
#[fn_builder]
pub fn alter_id(&mut self, id: &str) -> &mut Self {
self.id.alter_value(id);
self
}
#[fn_builder]
pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self {
self.classes.alter_value(op, classes);
self
}
pub fn with_item(mut self, item: MegaMenuItem) -> Self {
self.items.alter(PackOp::Add, ComponentRef::to(item));
self
}
pub fn alter_items(&mut self, op: PackOp, item: MegaMenuItem) -> &mut Self {
self.items.alter(op, ComponentRef::to(item));
self
}
#[fn_builder]
pub fn alter_template(&mut self, template: &str) -> &mut Self {
self.template = template.to_owned();
self
}
// MegaMenu GETTERS.
pub fn classes(&self) -> &Classes {
&self.classes
}
pub fn items(&self) -> &PackComponents {
&self.items
}
pub fn template(&self) -> &str {
self.template.as_str()
}
}