baseurl = "http://localhost/basyx/"
#baseurl = "http://localhost/"
#baseurl = ""
title = "Eclipse BaSyx"
theme = "hugo-universal-theme"
#themesDir = "../.."
languageCode = "en-us"
# Site language. Available translations in the theme's `/i18n` directory.
defaultContentLanguage = "en"
# Enable comments by entering your Disqus shortname
# disqusShortname = "devcows"
# Enable Google Analytics by entering your tracking code
# googleAnalytics = "UA-XXXXX-X"
googleAnalytics = ""

# Define the number of posts per page
paginate = 10
# Adding this COMMENT for testing

[menu]

# Main menu

[[menu.main]]
    name = "Home"
    url  = "/"
    weight = 10

[[menu.main]]
    name = "About"
    url  = "/about/"
    weight = 15

[[menu.main]]
    name = "Blog"
    url  = "/blog/"
    weight = 20

[[menu.main]]
    name = "Forum"
    url  = "https://www.eclipse.org/forums/index.php/f/386/"
    weight = 30

[[menu.main]]
    name = "Resources"
    url  = "/resources/"
    weight = 40

[[menu.main]]
    name = "PMI Community"
    url  = "https://projects.eclipse.org/projects/iot.kuksa"
    weight = 40


#[[menu.main]]
#    name = "Events"
#    url  = "/calendar/"
#    weight = 50

# Top bar social links menu

[[menu.topbar]]
    weight = 1
    name = "GitHub"
    url = "https://github.com/eclipse?utf8=✓&q=kuksa"
    pre = "<i class='fa fa-2x fa-github'></i>"

#[[menu.topbar]]
#    weight = 2
#    name = "Facebook"
#    url = "http://facebook.com"
#    pre = "<i class='fa fa-2x fa-facebook'></i>"

[[menu.topbar]]
    weight = 3
    name = "Twitter"
    url = "http://twitter.com/Appstacle"
    pre = "<i class='fa fa-2x fa-twitter'></i>"

[[menu.topbar]]
    weight = 4
    name = "Email"
    url = "mailto:kuksa-dev@eclipse.org"
    pre = "<i class='fa fa-2x fa-envelope'></i>"

[params]
    viewMorePostLink = "/blog/"
    author = "Admin"
    defaultKeywords = ["iot", "smart mobility", "kuksa", "appstacle"]
    defaultDescription = "Eclipse KUKSA community website"

    # Google Maps API key (if not set will default to not passing a key.)
    #googleMapsApiKey = "AIzaSyCFhtWLJcE30xOAjcbSFi-0fnoVmQZPb1Y"

    # Style options: default (light-blue), blue, green, marsala, pink, red, turquoise, violet
    style = "turquoise"

    # Since this template is static, the contact form uses www.formspree.io as a
    # proxy. The form makes a POST request to their servers to send the actual
    # email. Visitors can send up to a 1000 emails each month for free.
    #
    # What you need to do for the setup?
    #
    # - set your email address under 'email' below
    # - upload the generated site to your server
    # - send a dummy email yourself to confirm your account
    # - click the confirm link in the email from www.formspree.io
    # - you're done. Happy mailing!
    #
    # Enable the contact form by entering your Formspree.io email
    email = ""

    #copyright = "Copyright © 2019 The Eclipse Foundation. All Rights Reserved."

    # Format dates with Go's time formatting
    date_format = "January 2, 2006"

    logo = "img/basyxlogotest.png"
   #address = """<p><strong>Universal Ltd.</strong>
   #     <br>13/25 New Avenue
   #     <br>Newtown upon River
   #     <br>45Y 73J
   #     <br>England
   #     <br>
   #     <strong>Great Britain</strong>
   #   </p>
   #   """
   # latitude = "-12.043333"
   # longitude = "-77.028333"

[Permalinks]
    blog = "/blog/:year/:month/:day/:filename/"

# Enable or disable top bar with social icons
[params.topbar]
    enable = true
    text = """<p class="hidden-sm hidden-xs">Contact us on <a href="mailto:basyx-dev@eclipse.org">basyx-dev@eclipse.org</a></p>
      <p class="hidden-md hidden-lg"><a href="#" data-animate-hover="pulse"><i class="fa fa-phone"></i></a>
      <a href="#" data-animate-hover="pulse"><i class="fa fa-envelope"></i></a>
      </p>
      """

# Enable and disable widgets for the right sidebar
[params.widgets]
    categories = true
    tags = true
    search = true

[params.carousel]
    enable = true
    # All carroussel items are defined in their own files. You can find example items
    # at 'exampleSite/data/carousel'.
    # For more information take a look at the README.

[params.features]
    enable = true
    # All features are defined in their own files. You can find example items
    # at 'exampleSite/data/features'.
    # For more informtion take a look at the README.
    title = "Features"
    
[params.video]
    enable = false
    title = "Basissystem Industrie 4.0"
    subtitle = "Eine offene Plattform für die vierte industrielle Revolution"
    url  = "http://www.basys40.de/wp-content/uploads/2014/09/BaSys-HP.mp4"

[params.clients]
    enable = true
    # All clients are defined in their own files. You can find example items
    # at 'exampleSite/data/clients'.
    # For more information take a look at the README.
    title = "Our Partners"
    subtitle = ""

[params.recent_posts]
    enable = true
    title = "Our latest news"
    subtitle = ""

[params.about]
    enable = true
    title = "ITEA3 Project"
