ვერსია 2.x


ძირითადი გამოყენება

ატვირთეთ Gridzy ფაილები თქვენს სერვერზე და დაამატეთ ისინი თქვენს ვებსაიტზე (ჩვეულებრივ, თავში):

<link rel="stylesheet" href="gridzy/gridzy.min.css" />
<script src="gridzy/gridzy.min.js"></script>

დაამატეთ HTML კოდი (სხეულის განყოფილების ნებისმიერ ადგილას):

<div class="gridzy">
  <img src="https://loremflickr.com/640/480?random=1" alt="a random image" />
  <img src="https://loremflickr.com/480/640?random=2" alt="another random image" />
  <img src="https://loremflickr.com/640/640?random=3" alt="yet another random image" />
  <img src="https://loremflickr.com/640/480?random=4" alt="a random image again" />
  <img src="https://loremflickr.com/640/480?random=5" alt="one last random image" />
</div>

ესე იგი! ეს არის სრულიად ფუნქციონალური მაგალითი. დამატებითი ინიციალიზაცია არ არის საჭირო.

კონფიგურაცია

Gridzy-ის კონფიგურაციის უმარტივესი გზაა უბრალოდ HTML ატრიბუტების გამოყენება. საჭიროა მხოლოდ ოფციონის სახელების პრეფიქსი data-gridzy- . ასე რომ, spaceBetween ოფციის დასაყენებლად, უბრალოდ დაამატეთ ატრიბუტი data-gridzy-spaceBetween .

<div class="gridzy" data-gridzy-spaceBetween="20" data-gridzy-desiredHeight="400">
  <img src="https://loremflickr.com/640/480?random=1" alt="a random image" />
  <img src="https://loremflickr.com/480/640?random=2" alt="another random image" />
  <img src="https://loremflickr.com/640/640?random=3" alt="yet another random image" />
  <img src="https://loremflickr.com/640/480?random=4" alt="a random image again" />
  <img src="https://loremflickr.com/640/480?random=5" alt="one last random image" />
</div>

ძირითადი პარამეტრები

ნაგულისხმევი მნიშვნელობააღწერა
animatetrueგანსაზღვრავს თუ არა ანიმაციების გამოყენება ბადის შეცვლისას (მაგალითად, ბრაუზერის ფანჯრის ზომის შეცვლისას ან ფილტრის დაყენებისას).
layoutjustifiedგანსაზღვრავს გამოყენებულ განლაგებას. Gridzy.js 2 მხარს უჭერს ორ განსხვავებულ განლაგებას justified და waterfall . თითოეულ მათგანს აქვს საკუთარი დამატებითი პარამეტრი, რომელიც შეგიძლიათ იხილოთ ამ ცხრილის ქვემოთ.
filter*განსაზღვრავს რომელი სურათები უნდა იყოს ნაჩვენები. ნებისმიერი CSS-ის სელექტორი შეიძლება გამოყენებულ იქნას როგორც მნიშვნელობა აქ. ჩვეულებრივ დაყენებულია ავტომატურად filterControls მეშვეობით (იხილეთ შემდეგი ვარიანტი).
შეამოწმეთ ფილტრები
filterControlsადგენს, რომელი ფორმის ელემენტები შეიძლება გამოყენებულ იქნას სურათების გასაფილტრად. ნებისმიერი CSS სელექტორი, რომელიც ირჩევს HTML ფორმის ელემენტებს, შეიძლება გამოყენებულ იქნას როგორც მნიშვნელობა აქ.
შეამოწმეთ ფილტრები
autoConsiderScrollBarstrueხელმისაწვდომი სიგანის პროგნოზირება, თუ გადახვევის ზოლები გამოჩნდება ან გაქრება. ყოველთვის რეკომენდირებულია დატოვოთ ის true , თუ ეს ავტომატიზმი არ იწვევს პრობლემებს.

Justified განლაგების პარამეტრები

ნაგულისხმევი მნიშვნელობააღწერა
autoFontSizefalseავტომატურად აახლებს თითოეული ველის შრიფტის ზომის თვისებებს თავდაპირველი ყუთის ზომაზე დაყრდნობით. ნაგულისხმევად, შრიფტის ზომის თვისება აშკარად არ არის მითითებული.
desiredHeight190განსაზღვრავს ელემენტის რიგების სასურველ სიმაღლეს. რეალური სიმაღლე გამოითვლება ხელმისაწვდომი სიგანისა და მწკრივის ელემენტების მიხედვით.
hideOnMissingImagetrueმალავს ყუთებს, რომლებიც შეიცავს სურათებს, რომლებიც ვერ ჩაიტვირთა.
spaceBetween4განსაზღვრავს ელემენტებს შორის მანძილს პიქსელებში.
lastRowAlign
2.3.0 ვერსიიდან
justifiedგანსაზღვრავს ბოლო რიგის ქცევას. დაშვებული მნიშვნელობებია left , center , right და justified .
singleRowAlign
2.3.0 ვერსიიდან
justifiedგანსაზღვრავს ქცევას, თუ მხოლოდ ერთი მწკრივია. დაშვებული მნიშვნელობებია left , center , right და justified .
fillLastRow
2.1.0 ვერსიიდან
trueწაშლილია 2.4.0 ვერსიიდან (მოძველებულია 2.3.0 ვერსიიდან )
აწყობს სურათებს ისე, რომ ბოლო მწკრივი ყოველთვის სრულად იყოს შევსებული. თუ სურათების დინამიურად დამატებას გეგმავთ, ამის გამორთვა კარგი იდეაა.
არ მოქმედებს ცალკეულ მწკრივებზე (იხ. fillSingleRow ).
fillSingleRow
2.1.0 ვერსიიდან
trueწაშლილია 2.4.0 ვერსიიდან (მოძველებულია 2.3.0 ვერსიიდან )
თუ მხოლოდ ერთი მწკრივია, ის აწყობს სურათებს ისე, რომ მწკრივი ყოველთვის მთლიანად ივსება. თუ შეიძლება მოხდეს, რომ გალერეაში მხოლოდ ერთი ან ორი სურათი გქონდეთ, ამის გამორთვა კარგი იდეაა.

Waterfall განლაგების პარამეტრები

ნაგულისხმევი მნიშვნელობააღწერა
autoFontSizefalseავტომატურად აახლებს თითოეული ველის შრიფტის ზომის თვისებებს თავდაპირველი ყუთის ზომაზე დაყრდნობით. ნაგულისხმევად, შრიფტის ზომის თვისება აშკარად არ არის მითითებული.
desiredWidth250განსაზღვრავს სვეტების სასურველ სიგანეს. რეალური სიგანე გამოითვლება ხელმისაწვდომი სიგანისა და სვეტების რაოდენობის მიხედვით.
hideOnMissingImagetrueმალავს ყუთებს, რომლებიც შეიცავს სურათებს, რომლებიც ვერ ჩაიტვირთა.
horizontalOrderfalseგანსაზღვრავს, რომ ელემენტები მოთავსებულია მკაცრად თითო ელემენტში თითოეულ სვეტში მარცხნიდან მარჯვნივ, შემდეგ ისევ იწყება ყველაზე მარცხენა სვეტში დამოუკიდებლად, რომელ სვეტში არის მეტი ადგილი. ნაგულისხმევად ელემენტები ყოველთვის განთავსდება ყველაზე პატარა სიმაღლის სვეტში.
spaceBetween4განსაზღვრავს ელემენტებს შორის მანძილს პიქსელებში.
singleRowAlign
since version 2.7.0
justifiedDefines the behavior when not all columns can be filled due to too few images. Allowed values are left, center, right and justified.

დამატებითი გაფართოებული პარამეტრები

უფრო მოწინავე ვარიანტებისთვის, შეამოწმეთ API .

სემანტიკური HTML

Gridzy-ს უმარტივესი HTML სტრუქტურა ასეთია:

<div class="gridzy">
  <img src="https://loremflickr.com/640/480?random=1" alt="a random image" />
  <img src="https://loremflickr.com/480/640?random=2" alt="another random image" />
  <img src="https://loremflickr.com/640/640?random=3" alt="yet another random image" />
  <img src="https://loremflickr.com/640/480?random=4" alt="a random image again" />
  <img src="https://loremflickr.com/640/480?random=5" alt="one last random image" />
</div>

თუმცა, Gridzy არის ძალიან მოქნილი და შეგიძლიათ გამოიყენოთ თითქმის ნებისმიერი სხვა HTML სტრუქტურა. გასათვალისწინებელია მხოლოდ რამდენიმე პუნქტი:

  • კონტეინერის ელემენტის თითოეული შვილი წარმოადგენს ერთ ელემენტს ბადეში.
  • კონტეინერის ელემენტიც და მისი ბავშვებიც შეიძლება იყოს ნებისმიერი ტიპის ტეგი, როგორიცაა ul და li (უბრალოდ განიხილეთ ბრაუზერის ნაგულისხმევი პარამეტრების გადატვირთვა).
  • თუ img ელემენტი არ არის უშუალო შვილი, მას სჭირდება კლასი gridzyImage .

ასე რომ, ეს არის ასევე სამუშაო HTML სტრუქტურა:

<ul class="gridzy">
  <li>
    <span>
      <img class="gridzyImage" src="https://loremflickr.com/640/480?random=1" alt="a random image" />
    </span>
  </li>
  <li>
    <span>
      <img class="gridzyImage" src="https://loremflickr.com/480/640?random=2" alt="another random image" />
    </span>
  </li>
  <li>
    <span>
      <img class="gridzyImage" src="https://loremflickr.com/640/640?random=3" alt="yet another random image" />
    </span>
  </li>
  <li>
    <span>
      <img class="gridzyImage" src="https://loremflickr.com/640/480?random=4" alt="a random image again" />
    </span>
  </li>
  <li>
    <span>
      <img class="gridzyImage" src="https://loremflickr.com/640/480?random=5" alt="one last random image" />
    </span>
  </li>
</ul>

განსაკუთრებით თუ გსურთ წარწერების დამატება, გჭირდებათ გაფართოებული HTML სტრუქტურა. ამის შესახებ მეტის გასაგებად, გადახედეთ წარწერებს და სკინებს .

წარწერები და სკინები

თუ გსურთ დაამატოთ წარწერები თქვენს გალერეაში, უნდა განსაზღვროთ გარეგნობა. ამიტომ, რამდენიმე წინასწარ განსაზღვრული სკინი ხელმისაწვდომია. თითოეული სკინი შედგება CSS ფაილისგან. თქვენ უნდა დაამატოთ ეს ფაილი ძირითადი Gridzy ფაილების გარდა (ჩვეულებრივ, თავში):

<link rel="stylesheet" href="gridzy/skins/gridzySkinClassic/style.min.css" />

გარდა ამისა, თქვენ გჭირდებათ გაფართოებული HTML სტრუქტურა:

<div class="gridzy gridzySkinClassic">
  <figure>
    <img class="gridzyImage" src="https://loremflickr.com/640/480?random=1" alt="a random image" />
    <figcaption class="gridzyCaption">a caption text</figcaption>
  </figure>
  <figure>
    <img class="gridzyImage" src="https://loremflickr.com/480/640?random=2" alt="another random image" />
    <figcaption class="gridzyCaption">another caption text</figcaption>
  </figure>
  <figure>
    <img class="gridzyImage" src="https://loremflickr.com/640/640?random=3" alt="yet another random image" />
    <figcaption class="gridzyCaption">yet another caption text</figcaption>
  </figure>
  <figure>
    <img class="gridzyImage" src="https://loremflickr.com/640/480?random=4" alt="a random image again" />
    <figcaption class="gridzyCaption">a caption text again</figcaption>
  </figure>
  <figure>
    <img class="gridzyImage" src="https://loremflickr.com/640/480?random=5" alt="one last random image" />
    <figcaption class="gridzyCaption">one last caption text</figcaption>
  </figure>
</div>

თუ გაინტერესებთ HTML სტრუქტურა, გადახედეთ სემანტიკური HTML- ს.

წარწერისთვის შეგიძლიათ გამოიყენოთ ნებისმიერი ტიპის ტეგი, უბრალოდ დარწმუნდით, რომ მას აქვს კლასის gridzyCaption . img ელემენტს სჭირდება კლასი gridzyImage .

ზემოთ მოყვანილი მაგალითი გიჩვენებთ კანს gridzySkinClassic . განსხვავებულის გამოსაყენებლად, უბრალოდ შეცვალეთ კანის სახელი ერთ-ერთით:

მოყვება სკინები

ხელმისაწვდომი კლასები
gridzySkinBlank
კარგი საწყისი წერტილი საკუთარი კანის შესაქმნელად
ცოცხალი გადახედვა
gridzySkinBlank
gridzySkinClassic
ცოცხალი გადახედვა
gridzySkinClassic
gridzySkinClassicLight(მოძველებულია 2.6.0 ვერსიიდან)
gridzySkinFullOverlay
ცოცხალი გადახედვა
gridzySkinFullOverlay
gridzySkinFullOverlayLight(მოძველებულია 2.6.0 ვერსიიდან)
gridzySkinLift
ცოცხალი გადახედვა
gridzySkinLift
gridzySkinLiftLight(მოძველებულია 2.6.0 ვერსიიდან)
gridzySkinMagnifier
მასშტაბირების ფუნქცია არ შედის
ცოცხალი გადახედვა
gridzySkinMagnifier
gridzySkinMagnifierLight(მოძველებულია 2.6.0 ვერსიიდან)

ყველა ზემოთ ჩამოთვლილ სკინს სჭირდება მხოლოდ CSS ფაილი, მაგრამ არის დამატებითი სკინები, რომლებიც ასევე საჭიროებენ JavaScript ფაილს:

<link rel="stylesheet" href="gridzy/skins/gridzySkinBlur/style.min.css" />
<script src="gridzy/skins/gridzySkinBlur/script.min.js"></script>
ხელმისაწვდომი კლასები
gridzySkinBlur
IE-ში არ მუშაობს
ცოცხალი გადახედვა
gridzySkinBlur
gridzySkinBlurLight(მოძველებულია 2.6.0 ვერსიიდან)
gridzySkinCard
ცოცხალი გადახედვა
gridzySkinCard
gridzySkinCardLight(მოძველებულია 2.6.0 ვერსიიდან)

კანის პარამეტრები

2.6.0 ვერსიიდან არის ჩაშენებული სკინების კონფიგურაციის პარამეტრები. კონკრეტული კანის მიხედვით შეგიძლიათ დააყენოთ ფონის ფერი, ტექსტის ფერი და ტექსტის ჩრდილი. თქვენ უბრალოდ უნდა გამოიყენოთ CSS პერსონალური თვისებები, როგორც ხედავთ აქ:

<div class="gridzy gridzySkinClassic" style="--background: rgba(0, 80, 117, .8); --color: rgb(238, 238, 238); ">
  <figure>
    <img class="gridzyImage" src="https://loremflickr.com/640/480?random=1" alt="a random image" />
    <figcaption class="gridzyCaption">a caption text</figcaption>
  </figure>
  <figure>
    <img class="gridzyImage" src="https://loremflickr.com/480/640?random=2" alt="another random image" />
    <figcaption class="gridzyCaption">another caption text</figcaption>
  </figure>

  ...

</div>

შეამოწმეთ მხარდაჭერილი ცვლადები და ნაგულისხმევი მნიშვნელობები თითოეული კანისთვის აქ:

gridzySkinClassic
ცვლადინაგულისხმევი მნიშვნელობაინფორმაცია
--backgroundrgba(0, 0, 0, .7)საშუალებას აძლევს ნებისმიერ CSS ფონის მნიშვნელობას
--colorrgb(255, 255, 255)საშუალებას აძლევს ნებისმიერ CSS ფერის მნიშვნელობას
--text-shadownoneსაშუალებას აძლევს CSS ტექსტის ჩრდილის ნებისმიერ მნიშვნელობას
gridzySkinFullOverlay
ცვლადინაგულისხმევი მნიშვნელობაინფორმაცია
--backgroundrgba(0, 0, 0, .7)საშუალებას აძლევს ნებისმიერ CSS ფონის მნიშვნელობას
--colorrgb(255, 255, 255)საშუალებას აძლევს ნებისმიერ CSS ფერის მნიშვნელობას
--text-shadownoneსაშუალებას აძლევს CSS ტექსტის ჩრდილის ნებისმიერ მნიშვნელობას
gridzySkinLift
ცვლადინაგულისხმევი მნიშვნელობაინფორმაცია
--backgroundrgba(0, 0, 0, .7)საშუალებას აძლევს ნებისმიერ CSS ფონის მნიშვნელობას
--colorrgb(255, 255, 255)საშუალებას აძლევს ნებისმიერ CSS ფერის მნიშვნელობას
--text-shadow0 0 10px rgb(0, 0, 0), 0 0 20px rgb(0, 0, 0), 0 0 30px rgb(0, 0, 0)საშუალებას აძლევს CSS ტექსტის ჩრდილის ნებისმიერ მნიშვნელობას
gridzySkinMagnifier
ცვლადინაგულისხმევი მნიშვნელობაინფორმაცია
--backgroundrgba(0, 0, 0, .7)საშუალებას აძლევს ნებისმიერ CSS ფონის მნიშვნელობას
--colorrgb(255, 255, 255)საშუალებას აძლევს ნებისმიერ CSS ფერის მნიშვნელობას

ეს კანი არ უჭერს მხარს --text-shadow

gridzySkinBlur
ცვლადინაგულისხმევი მნიშვნელობაინფორმაცია
--backgroundrgba(0, 0, 0, .7)საშუალებას აძლევს ნებისმიერ CSS ფონის მნიშვნელობას
--colorrgb(255, 255, 255)საშუალებას აძლევს ნებისმიერ CSS ფერის მნიშვნელობას
--text-shadow0 0 10px rgb(0, 0, 0)საშუალებას აძლევს CSS ტექსტის ჩრდილის ნებისმიერ მნიშვნელობას
gridzySkinCard
ცვლადინაგულისხმევი მნიშვნელობაინფორმაცია
--backgroundrgba(0, 0, 0, 1)საშუალებას აძლევს ნებისმიერ CSS ფონის მნიშვნელობას
--colorrgb(255, 255, 255)საშუალებას აძლევს ნებისმიერ CSS ფერის მნიშვნელობას
--text-shadownoneსაშუალებას აძლევს CSS ტექსტის ჩრდილის ნებისმიერ მნიშვნელობას

ყველა წინასწარ განსაზღვრული სკინი მხარს უჭერს მხოლოდ ტექსტის მარტივ წარწერებს. თქვენ შეგიძლიათ შექმნათ თქვენი საკუთარი და უფრო რთული სკინები. გთხოვთ გადახედოთ გრიდზის სტილს .

გრიდზის სტილი

თუ წინასწარ განსაზღვრული კანი არ შეესაბამება თქვენს მოთხოვნილებებს, შეგიძლიათ საკუთარი სტილის სტილი.

უმარტივესი გზაა ჯერ არსებული კანის კოპირება და საკუთარ საჭიროებებზე ადაპტირება. წინასწარ განსაზღვრული კანის gridzySkinBlank ჩვეულებრივ უზრუნველყოფს კარგ საფუძველს და ასევე კარგ დოკუმენტაციას CSS ფაილში:

/** SKIN Blank **/

/* all gallery items (direct children of the main container element) */
.gridzySkinBlank > .gridzyItem {
  overflow: hidden;
}

/* all gallery images (predefined in Gridzy's main CSS file, but can be overridden) */
.gridzySkinBlank .gridzyImage {
}

/* all gallery captions (just create your very own style) */
.gridzySkinBlank .gridzyCaption {
  margin: 0;
  padding: .5em;
  opacity: 0;
  display: flex;
  justify-content: center;
  align-items: center;
  text-align: center;
  position: absolute;
  z-index: 1;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  box-sizing: border-box;
  transition: opacity .5s;
  overflow: auto;
  background: rgba(0, 0, 0, .7);
  color: rgb(255, 255, 255);
}

.gridzySkinBlank > .gridzyItem:hover .gridzyCaption {
  opacity: 1;
}

CSS ფაილში ნახავთ კლასებს gridzySkinBlank , gridzyImage და gridzyCaption . თავად გრიდზის არ სჭირდება ეს კლასები. ისინი გამოიყენება მხოლოდ სტილისთვის და ასე რომ, თუ გსურთ, შეგიძლიათ წაშალოთ ან გადაარქვათ სახელი.

დამატებით თქვენ იპოვით CSS კლასის gridzyItem . Gridzy ავტომატურად აყენებს ამ კლასს ძირითადი კონტეინერის ელემენტის ყველა პირდაპირ ბავშვზე. ასე რომ, შეგიძლიათ გამოიყენოთ ეს კლასი თქვენი გალერეის ელემენტების სტილისთვის.

გაითვალისწინეთ მნიშვნელოვანი რამ

  1. საქონლის შიგთავსი უნდა იყოს სრულად საპასუხო. გაითვალისწინეთ, რომ ელემენტის ზომა აუცილებლად შეიცვლება. გამოიყენეთ პროცენტული მნიშვნელობები პიქსელის მნიშვნელობების ნაცვლად. და შეხედეთ Gridzy განლაგების ოფციას autoFontSize , რომელიც აკავშირებს შრიფტის ზომას ელემენტის ყუთის ზომაზე.
  2. თითოეულ ელემენტს უნდა ჰქონდეს კარგად განსაზღვრული ასპექტის თანაფარდობა. ელემენტის ასპექტის თანაფარდობა არასოდეს შეიცვლება და საჭიროა ბადის გამოსათვლელად. ასე რომ, თუ ელემენტს ავტომატურად არ აქვს კარგად განსაზღვრული ასპექტის თანაფარდობა, წინასწარ განსაზღვრეთ იგი ხელით (მაგ. css-ის საშუალებით).

ზოგიერთ შემთხვევაში, შეიძლება გაადვილდეს ელემენტების შინაარსის სტილიზაცია გრიდზის ინიციალიზაციამდე. ამისათვის უბრალოდ წაშალეთ კლასის gridzy ან Gridzy javascript ფაილი დროებით.

ესე იგი! ეს არის ყველაფერი, რაც გჭირდებათ საკუთარი კანის შესაქმნელად. წინასწარ განსაზღვრული სკინების უმეტესობა ამაზე მეტს არ იყენებს.

მაგრამ შეიძლება მეტი იყოს, თუ გნებავთ…

Advanced Skins

Gridzy იყენებს უფრო მეტ CSS კლასს, ვიდრე მხოლოდ gridzyItem . მათი უმეტესობა ავტომატურად დაყენდება და შეგიძლიათ გამოიყენოთ ისინი სტილისთვისაც.

კონტეინერის ძირითადი კლასები

კლასის სახელიაღწერა
gridzy
ხელით დასაყენებლად
Gridzy ავტომატურად პოულობს ელემენტებს ამ კლასში და ახდენს მათ ინიციალიზაციას.
gridzyAnimatedავტომატურად დაყენდება, თუ ვარიანტი animate არის true . თუ ეს კლასი დაყენებულია ხელით, პარამეტრი animate ავტომატურად გახდება true (გარდა იმ შემთხვევისა, თუ ის აშკარად დაყენებულია false ზე).

ნივთის კლასები

კლასის სახელიაღწერა
gridzyItemდაყენდება როგორც კი ელემენტი დაიწყებს ინიციალიზაციის პროცესს. არასოდეს მოიხსნება.
gridzyItemInitializingდაყენდება როგორც კი ელემენტი დაიწყებს ინიციალიზაციის პროცესს. ჩანაცვლდება gridzyItemReady ით, როგორც კი ელემენტი სრულად იქნება ინიცირებული. არ ნიშნავს, რომ სურათები სრულად არის ჩატვირთული (იხ. gridzyItemLoading ), მაგრამ ელემენტი მზად არის ხილვადისთვის.
gridzyItemReadyჩაანაცვლებს gridzyItemInitializing როგორც კი ელემენტი სრულად ინიციალიზდება. არასოდეს მოიხსნება. არ ნიშნავს, რომ სურათები სრულად არის დატვირთული (იხ. gridzyItemComplete ), მაგრამ ელემენტი მზად არის ხილვადისთვის.
gridzyItemLoadingდაყენდება როგორც კი ელემენტი დაიწყებს ინიციალიზაციის პროცესს. შეიცვლება gridzyItemComplete ით, როგორც კი შეიცავს სურათები (ჩვეულებრივ მხოლოდ ერთი) სრულად ჩაიტვირთება.
gridzyItemCompleteჩაანაცვლებს gridzyItemLoading , როგორც კი შეიცავს სურათები (ჩვეულებრივ მხოლოდ ერთი) სრულად ჩაიტვირთება. არასოდეს მოიხსნება.
gridzyItemInitialToVisibleდაყენდება, როგორც კი ელემენტი პირველად გამოჩნდება. წაიშლება, როგორც კი ელემენტი სრულად გამოჩნდება.
gridzyItemVisibleდაყენდება, როგორც კი ელემენტი სრულად გამოჩნდება. წაიშლება როგორც კი ელემენტი დაიწყებს გაქრობას.
gridzyItemVisibleToHiddenდაყენდება, როგორც კი ელემენტი დაიწყებს გაქრობას. წაიშლება როგორც კი ელემენტი მთლიანად დაიმალება.
gridzyItemHiddenდაყენდება, როგორც კი ელემენტი მთლიანად დამალულია. წაიშლება როგორც კი ელემენტი გამოჩნდება.
gridzyItemHiddenToVisibleდაყენდება როგორც კი ელემენტი გამოჩნდება (გარდა პირველად გამოჩენისა – იხილეთ კლასი gridzyItemInitialToVisible ). წაიშლება, როგორც კი ელემენტი სრულად გამოჩნდება.
gridzyItemVisibleToVisibleდაყენდება, როგორც კი ბადეში რაღაც შეიცვლება, მაგრამ თავად ელემენტი იყო და რჩება ხილული. წაიშლება ცვლილების ანიმაციის დასრულებისთანავე.

ნაგულისხმევად პროცესის ინდიკატორი და სურათების გამოჩენისა და გაქრობის ანიმაციები წინასწარ განსაზღვრულია Gridzy-ის მთავარი CSS ფაილით.

ზემოთ ჩამოთვლილი CSS კლასებით თქვენ შეგიძლიათ საკუთარი პროცესის ინდიკატორისა და ანიმაციის სტილი. გაბედეთ გადახედოთ Gridzy-ს მთავარ CSS ფაილს, რათა გაიგოთ, რისი გადალახვა მოგიწევთ. არავითარი შიში, იქ ყველაფერი კარგად არის დოკუმენტირებული.

ჩატვირთვის ოპტიმიზაცია

თუ ბევრ სურათს იყენებთ, კარგი იდეა იქნება, რომ დაეხმაროთ გრიდზის ბადის უფრო სწრაფად აშენებაში.

სურათების გადახტომის თავიდან აცილება

გრიდზის აბსოლუტურად სჭირდება ყველა სურათის ასპექტის თანაფარდობა ბადის გამოსათვლელად. ეს ფაქტი იწვევს ელემენტების გადახტომას, თუ ზოგიერთი სურათი მზად არის, ზოგი კი არა. რაც მეტი სურათია, მით უფრო შემაშფოთებელი შეიძლება იყოს ეს ეფექტი.

ამ ქცევის თავიდან ასაცილებლად, უბრალოდ დააყენეთ width და height ყველა img ელემენტისთვის. მნიშვნელოვანია თითოეული სურათისთვის სწორი მნიშვნელობების დაყენება, წინააღმდეგ შემთხვევაში სურათები დამახინჯდება. სწორი მნიშვნელობებია შესაბამისი სურათის საწყისი სიგანე და სიმაღლე:

<div class="gridzy">
  <img src="https://loremflickr.com/640/480?random=1" width="640" height="480" alt="a random image" />
  <img src="https://loremflickr.com/480/640?random=2" width="480" height="640" alt="another random image" />
  <img src="https://loremflickr.com/640/640?random=3" width="640" height="640" alt="yet another random image" />
  <img src="https://loremflickr.com/640/480?random=4" width="640" height="480" alt="a random image again" />
  <img src="https://loremflickr.com/640/480?random=5" width="640" height="480" alt="one last random image" />
</div>

ამის შემდეგ გრიდზის შეუძლია დაუყოვნებლივ გამოთვალოს ბადე, სურათების რეალური ზომის ცოდნის გარეშე.

Lazy Loading

მხოლოდ ხილულ ხედში მყოფი სურათების ჩასატვირთად, უბრალოდ მიჰყევით ამ ნაბიჯებს:

  1. width და height ატრიბუტების ჩასმა, როგორც ზემოთ აღწერილია (დარწმუნდით, რომ გამოიყენეთ სწორი მნიშვნელობები)
  2. ჩაანაცვლეთ ყველა src ატრიბუტი data-gridzylazysrc ით, როგორც ეს ნაჩვენებია ქვემოთ (თუ თქვენ გაქვთ srcset ატრიბუტებიც, შეცვალეთ ისინი data-gridzylazysrcset ).
<div class="gridzy">
  <img data-gridzylazysrc="https://loremflickr.com/640/480?random=1" width="640" height="480" alt="a random image" />
  <img data-gridzylazysrc="https://loremflickr.com/480/640?random=2" width="480" height="640" alt="another random image" />
  <img data-gridzylazysrc="https://loremflickr.com/640/640?random=3" width="640" height="640" alt="yet another random image" />
  <img data-gridzylazysrc="https://loremflickr.com/640/480?random=4" width="640" height="480" alt="a random image again" />
  <img data-gridzylazysrc="https://loremflickr.com/640/480?random=5" width="640" height="480" alt="one last random image" />
</div>

ამ ნაბიჯების შემდეგ სურათები იტვირთება როგორც კი ისინი ხედის პორტთან ახლოს ან შიგნით იქნებიან.

პროცესის ინდიკატორი

პროცესის ინდიკატორი არის პატარა ანიმაციური ხატულა, რომელიც გამოჩნდება სურათის ჩატვირთვისას. თუ იყენებთ წარწერებს და სკინებს , პროცესის მაჩვენებელი ავტომატურად გამოჩნდება. წინააღმდეგ შემთხვევაში საჭიროა გარკვეული კორექტირება:

  1. ჩადეთ თითოეული img ელემენტი div ელემენტში
    (ან ნებისმიერ სხვა ელემენტში - იხილეთ სემანტიკური HTML მეტი)
  2. დაამატეთ კლასი gridzyImage თითოეულ img ელემენტს
<div class="gridzy">
  <div><img src="https://loremflickr.com/640/480?random=1" class="gridzyImage" alt="a random image" /></div>
  <div><img src="https://loremflickr.com/480/640?random=2" class="gridzyImage" alt="another random image" /></div>
  <div><img src="https://loremflickr.com/640/640?random=3" class="gridzyImage" alt="yet another random image" /></div>
  <div><img src="https://loremflickr.com/640/480?random=4" class="gridzyImage" alt="a random image again" /></div>
  <div><img src="https://loremflickr.com/640/480?random=5" class="gridzyImage" alt="one last random image" /></div>
</div>

ამის შემდეგ თქვენ უნდა ნახოთ პროცესის ინდიკატორები, თუ სურათების ჩატვირთვას დრო სჭირდება.

ფილტრები

Gridzy-ში ფილტრები საკმაოდ მარტივია, მაგრამ ძლიერი. რა სახის ფილტრიც არ უნდა დაგჭირდეთ, დიდი ალბათობით, ის განხორციელდება. ყველაფერი რაც თქვენ გჭირდებათ არის, ცოტა CSS და რამდენიმე HTML ფორმის ელემენტი…

აქ არის ფუნქციური მაგალითი:

<div id="myFilterControls">
  <button value="*">All</button>
  <button value=".animals">Animals</button>
  <button value=".architecture">Architecture</button>
  <button value=".people">People</button>
</div>

<div class="gridzy" data-gridzy-filterControls="#myFilterControls button">
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=1" alt="a random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=1" alt="a random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=1" alt="a random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=2" alt="another random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=2" alt="another random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=2" alt="another random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=3" alt="yet another random animal image" />
</div>

მოდით ავაშენოთ ის ეტაპობრივად

1. ჯერ ჩვენ გვჭირდება Gridzy-ის ჩვეულებრივი HTML სტრუქტურა და დავაყენოთ კლასის სახელები ყველა გალერეის ელემენტისთვის, რათა შემდგომ შევძლოთ მათი გაფილტვრა

<div class="gridzy">
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=1" alt="a random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=1" alt="a random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=1" alt="a random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=2" alt="another random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=2" alt="another random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=2" alt="another random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=3" alt="yet another random animal image" />
</div>

ამ მაგალითში ჩვენ ვიყენებთ მხოლოდ ერთ კლასს თითოეული ელემენტისთვის. მაგრამ თქვენ ასევე შეგიძლიათ დააყენოთ მრავალი კლასი ერთი ელემენტისთვის, თუ ეს ელემენტი უნდა იყოს ნაპოვნი მრავალი ფილტრის საშუალებით.

2. შემდეგ დავამატებთ რამდენიმე ღილაკს, რომლის მეშვეობითაც შეგვიძლია შევცვალოთ ფილტრები

<button value="*">All</button>
<button value=".animals">Animals</button>
<button value=".architecture">Architecture</button>
<button value=".people">People</button>

<div class="gridzy">
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=1" alt="a random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=1" alt="a random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=1" alt="a random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=2" alt="another random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=2" alt="another random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=2" alt="another random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=3" alt="yet another random animal image" />
</div>

ღილაკების ნაცვლად, თქვენ ასევე შეგიძლიათ გამოიყენოთ ფორმის სხვა ელემენტები, როგორიცაა გამშვები ველები, რადიო ღილაკები, ველების შერჩევა და ა.შ.

როგორც ხედავთ, ღილაკების მნიშვნელობები ჩვეულებრივი CSS სელექტორებია. როგორც კი დავამთავრებთ, ასეთ ღილაკზე დაწკაპუნება გამოჩნდება იმ სურათებს, რომლებიც ემთხვევა ამ CSS სელექტორს. ტექნიკურად ის უბრალოდ აყენებს filter ვარიანტს ამ მნიშვნელობაზე.

თქვენ ასევე შეგიძლიათ გამოიყენოთ ბევრად უფრო რთული სელექტორები. მაგალითად :not(.animals) იმუშავებს, ისევე როგორც .animals.people და .animals, .people .

3. ბოლოს, ღილაკებს ვათავსებთ div კონტეინერში და ვუკავშირდებით Gridzy გალერეას filterControls ოფციის დაყენებით:

<div id="myFilterControls">
  <button value="*">All</button>
  <button value=".animals">Animals</button>
  <button value=".architecture">Architecture</button>
  <button value=".people">People</button>
</div>

<div class="gridzy" data-gridzy-filterControls="#myFilterControls button">
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=1" alt="a random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=1" alt="a random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=1" alt="a random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=2" alt="another random animal image" />
  <img class="architecture" src="https://loremflickr.com/640/480/arch?random=2" alt="another random architecture image" />
  <img class="people" src="https://loremflickr.com/640/480/people?random=2" alt="another random people image" />
  <img class="animals" src="https://loremflickr.com/640/480/animals?random=3" alt="yet another random animal image" />
</div>

როგორც ხედავთ, ჩვენ ასევე ვიყენებთ CSS სელექტორს filterControls ოფციისთვის. div კონტეინერი id ატრიბუტით ემსახურება მხოლოდ ღილაკების არჩევას ამ CSS სელექტორის მეშვეობით.

ესე იგი!

თუ გირჩევნიათ JavaScript გადაწყვეტა, შეამოწმეთ API .

API

მიუხედავად იმისა, რომ Gridzy-ს აქვს საკუთარი API, ბევრი რამ შეიძლება გაკეთდეს მის გარეშე, უბრალოდ DOM-ის მანიპულირებით. გრიძე ამას შეამჩნევს და ბადეს დაარეგულირებს. მაგრამ ასევე არის ძალიან ძლიერი API…

DOM-ის მანიპულირება

ყველა Document Object Model (DOM) მანიპულირებისთვის, პირველ რიგში გვჭირდება კონტეინერის ელემენტი:

// get the container element
var gridzyElement = document.querySelector('.gridzy');

სურათების დამატება

მნიშვნელოვანია, რომ სრულად ააშენოთ და შეავსოთ ახალი ბავშვის ელემენტი, სანამ დაამატებთ კონტეინერის ელემენტს. წინააღმდეგ შემთხვევაში გრიძე ვერ აღმოაჩენს სწორ ზომებს.

// create a new img element
var newImage = document.createElement('img');

// add src attribute (!! before you add it to the container element !!)
newImage.src = 'https://loremflickr.com/640/480';

// add it as last element to the container element
gridzyElement.appendChild(newImage);

// or as first element (or anywhere in between)
gridzyElement.insertBefore(newImage, gridzyElement.firstChild);

სურათების წაშლა

// remove the first image
gridzyElement.removeChild(gridzyElement.firstElementChild);

ოფციების შეცვლა

// change the spaceBetween option to a specific value
gridzyElement.setAttribute('data-gridzy-spaceBetween', '10');

// change the layout option to a specific value
gridzyElement.setAttribute('data-gridzy-layout', 'waterfall');

// reset the spaceBetween option to its default value
gridzyElement.removeAttribute('data-gridzy-spaceBetween');

მეტი DOM-ის მანიპულირების შესახებ შეგიძლიათ იხილოთ MDN ვებ დოკუმენტებზე . ასევე ხელმისაწვდომია DOM-ის შესავალი .

საკუთრების API

API-ს გამოსაყენებლად, ჯერ გვჭირდება Gridzy ინსტანცია, რომელიც უკავშირდება Gridzy კონტეინერის ელემენტს:

// get the Gridzy instance
var gridzyInstance = document.querySelector('.gridzy').gridzy;

მიიღეთ ვარიანტი

// get the value of a single option
var currentLayout = gridzyInstance.getOption('layout');

მიიღეთ ყველა ვარიანტი

// get all option values as an object
var currentOptions = gridzyInstance.getOptions();

პარამეტრების დაყენება

// set specific option values
gridzyInstance.setOptions({
  spaceBetween: 10,
  layout: 'waterfall'
});

// or reset options to their default values
gridzyInstance.setOptions({
  spaceBetween: null,
  layout: null
});

ფილტრის გამოყენება

ფილტრის გამოყენება მხოლოდ ოფციონის filter დაყენებაა, რომელიც შეიძლება იყოს ნებისმიერი მოქმედი CSS სელექტორი:

// set the filter to match items with class "animals"
gridzyInstance.setOptions({
  filter: '.animals'
});

// reset the filter to match all items again
gridzyInstance.setOptions({
  filter: '*'
});

// set the filter to match items without class "animals"
gridzyInstance.setOptions({
  filter: ':not(.animals)'
});

// set the filter to match items with class "animals" or "people"
gridzyInstance.setOptions({
  filter: '.animals, .people'
});

// set the filter to match items that have both classes, "animals" and "people"
gridzyInstance.setOptions({
  filter: '.animals.people'
});

დაამატეთ გამოძახების ფუნქციები

მოძველებულია 2.4.0 ვერსიიდან
გამოიყენეთ თანამედროვე და უფრო მოქნილი ღონისძიებები . იხილეთ შემდეგი განყოფილება დეტალებისთვის.

Gridzy.js 2 მხარს უჭერს გამოძახების ფუნქციების ზოგიერთ ვარიანტს. მათი დაყენება შესაძლებელია მხოლოდ საკუთრების API-ის საშუალებით, მაგრამ ისევე, როგორც სხვა ვარიანტები:

// same as set other options
gridzyInstance.setOptions({
  onOptionsChanged: function() {
    // will be executed each time the options have changed.
  },
  onBeforeOptionsChanged: function() {
    // will be executed, before new options take effect.
  }
});
აღწერა
onBeforeOptionsChangedგამოძახების ფუნქცია, რომელიც გამოიძახება პირდაპირ პარამეტრების დაყენებამდე.
onOptionsChangedგამოძახების ფუნქცია, რომელიც გამოიძახება პირდაპირ პარამეტრების დაყენების შემდეგ.
onBeforeRenderგამოძახების ფუნქცია, რომელიც გამოძახებულია პირდაპირ რენდერამდე.
onRenderგამოძახების ფუნქცია, რომელიც გამოიძახება პირდაპირ რენდერის შემდეგ.

გამოიყენეთ მოვლენები

2.4.0 ვერსიიდან

თქვენ შეგიძლიათ გამოიყენოთ Gridzy მოვლენები ზუსტად ისე, როგორც ჩვეულებრივი JavaScript მოვლენები:

document.addEventListener('gridzyOptionsChanged', function(event) {
    // will be executed each time the options have changed.
});

document.addEventListener('gridzyBeforeOptionsChanged', function(event) {
    // will be executed, before new options take effect.
});

ზოგიერთი მოვლენა ჩართულია Gridzy-ს კონტეინერის ელემენტზე და სხვა მოვლენები ჩართულია ცალკეულ ელემენტებზე კონტეინერის ელემენტში.

Gridzy კონტეინერის ელემენტზე გასროლილი მოვლენები:

აღწერა
gridzyBeforeInitხანძარი გალერეის ინიციალიზაციამდე.
gridzyInitხანძარი გალერეის ინიციალიზაციის შემდეგ.
gridzyBeforeOptionsChangedირთვება პარამეტრების დაყენებამდე.
gridzyOptionsChangedირთვება პარამეტრების დაყენების შემდეგ.
gridzyBeforeRenderხანძარი გაწევის წინ.
gridzyRenderხანძარი გაწევის შემდეგ.
თუ გამოტოვებთ რაიმე ღონისძიებას აქ, გთხოვთ, გამოაგზავნოთ მხარდაჭერის მოთხოვნა .

event.target უზრუნველყოფს Gridzy კონტეინერის ელემენტს.
event.detail.instance უზრუნველყოფს Gridzy მაგალითს.

ნივთების ელემენტებზე გასროლილი მოვლენები:

აღწერა
gridzyItemBeforeInitირთვება ნივთის ინიციალიზაციამდე.
gridzyItemInitირთვება ნივთის ინიციალიზაციის შემდეგ.
gridzyItemLoadingირთვება, როდესაც ელემენტი ჩატვირთვას იწყებს.
gridzyItemReadyირთვება, როდესაც ელემენტი მზად არის ბადის გამოსათვლელად. ასე რომ, ასპექტის თანაფარდობა ცნობილია, მაგრამ სურათი შეიძლება კვლავ იტვირთებოდეს.
gridzyItemCompleteირთვება, როდესაც ელემენტის სურათი სრულად იტვირთება.
თუ გამოტოვებთ რაიმე ღონისძიებას აქ, გთხოვთ, გამოაგზავნოთ მხარდაჭერის მოთხოვნა .

event.target უზრუნველყოფს შესაბამის ელემენტის ელემენტს.
event.detail.instance უზრუნველყოფს Gridzy მაგალითს.

API – გლობალური

არსებობს გარკვეული ფუნქციები, რომლებიც დამოუკიდებელია გრიდზის შემთხვევებისგან. ასე რომ, ჩვენ არ გვჭირდება ადრე ინსტანციის მიღება.

მიიღეთ ნაგულისხმევი ვარიანტი

// get the default value of a single option
var defaultLayout = Gridzy.getDefaultOption('layout');

მიიღეთ ყველა ნაგულისხმევი ვარიანტი

// get all default option values as an object, including the default layout options of the default layout
var defaultOptions = Gridzy.getDefaultOptions();

// or get all default option values, including the default layout options of a specific layout
var defaultOptions = Gridzy.getDefaultOptions('waterfall');

დააყენეთ ნაგულისხმევი პარამეტრები

ეს არ ადგენს ყველა უკვე ინიციალირებული Gridzy ინსტანციის ვარიანტებს, მაგრამ განსაზღვრავს საფუძველს ახალი ინსტანციებისთვის. თუმცა, თუ არსებული ინსტანციის ოფცია აღდგება null მნიშვნელობის მეშვეობით, ის გამოიყენებს ახალ ნაგულისხმევ მნიშვნელობას.

// set default option values
Gridzy.setDefaultOptions({
  spaceBetween: 10,
  layout: 'waterfall'
});

თქვენ შეგიძლიათ გამოიყენოთ ეს პარამეტრების გლობალურად დასაყენებლად, თუ დაურეკავთ, სანამ DOM მზად იქნება. ასე რომ, თქვენ აღარ დაგჭირდებათ პარამეტრების ატრიბუტებად დაყენება.

ავტომატიზმები

სანამ Gridzy.js 2-ის ყველა ავტომატიზმი აქტიურია, არ არის საჭირო ქვემოთ მოყვანილი მეთოდები. მაგრამ ავტომატიზმები შეიძლება გამორთოთ Gridzy უფრო ტრადიციული გზით გამოსაყენებლად:

// disable automatic initializations
Gridzy.setDefaultOptions({
  autoInitOnDomReady: false,
  autoInitOnDomMutation: false
});

// or switch off all mutation observers
Gridzy.setDefaultOptions({
  autoInitOnDomMutation: false,
  autoSyncChildListMutation: false,
  autoSyncAttributesMutation: false,
  autoSyncChildClassMutation: false,
  autoSyncImageMutation: false
});

ზოგიერთი ამ პარამეტრის დაყენება შეუძლებელია data-gridzy- ატრიბუტების ან setOptions() მეშვეობით, ლოგიკური მიზეზების გამო:

ნაგულისხმევი მნიშვნელობააღწერა
autoInitOnDomReadytrueაღმოაჩენს ელემენტებს კლასის gridzy ით გვერდის ჩატვირთვისას და ახდენს მათ ინიციალიზაციას.

დაყენება შესაძლებელია Gridzy.setDefaultOptions() საშუალებით
autoInitOnDomMutation
მუტაციის დამკვირვებელი
trueაღმოაჩენს ახალ ელემენტებს კლასის gridzy ით, როგორც კი ისინი გამოჩნდება DOM-ში და ახდენს მათ ინიციალიზებას. (მაგ. გვერდის გადასვლების გამოყენებისას)

დაყენება შესაძლებელია Gridzy.setDefaultOptions() საშუალებით
autoSyncChildListMutation
მუტაციის დამკვირვებელი
trueაღმოაჩენს, არის თუ არა დამატებითი ელემენტების (სურათების) დამატება ან წაშლა და ავტომატურად განაახლებს ბადეს.

დაყენება შესაძლებელია data-grizy- , new Gridzy() , setOptions() , Gridzy.setDefaultOptions() მეშვეობით
useOptionAttributestrueგანსაზღვრავს, ზოგადად გამოიყენება თუ არა data-gridzy- ატრიბუტები. თუ ეს false პარამეტრების დაყენება შესაძლებელია მხოლოდ საკუთრების API-ის საშუალებით.

დაყენება შესაძლებელია new Gridzy() , setOptions() , Gridzy.setDefaultOptions() მეშვეობით
autoSyncAttributesMutation
მუტაციის დამკვირვებელი
trueამოიცნობს data-gridzy- ატრიბუტების ცვლილებებს და ავტომატურად განაახლებს ქსელს. ასევე აღმოაჩენს, არის თუ არა gridzyAnimated კლასის დამატება ან წაშლა და ხდება თუ არა style ატრიბუტის ცვლილებები. თუ useOptionAttributes არის false , ის აღმოაჩენს მხოლოდ style ატრიბუტების ცვლილებებს.

დაყენება შესაძლებელია data-grizy- , new Gridzy() , setOptions() , Gridzy.setDefaultOptions() მეშვეობით
autoSyncChildClassMutation
მუტაციის დამკვირვებელი
trueაღმოაჩენს ყველა ბავშვის ელემენტის class ატრიბუტების ცვლილებას (სურათები). შესაბამისია ფილტრებთან დაკავშირებით.

დაყენება შესაძლებელია data-grizy- , new Gridzy() , setOptions() , Gridzy.setDefaultOptions() მეშვეობით
autoSyncImageMutation
მუტაციის დამკვირვებელი

2.5.0 ვერსიიდან
trueაღმოაჩენს ყველა სურათის src ატრიბუტების ცვლილებებს. რელევანტურია React-თან ან მსგავს ბიბლიოთეკებთან გამოყენებისას.

დაყენება შესაძლებელია data-grizy- , new Gridzy() , setOptions() , Gridzy.setDefaultOptions() მეშვეობით
autoRenderOnResize
ResizeObserver

2.6.0 ვერსიიდან
trueამოიცნობს ელემენტის სიგანის ცვლილებებს. რელევანტურია საპასუხო დიზაინთან დაკავშირებით. (2.6.0 ვერსიამდე გამოყენებული იყო ფანჯრის ზომის შეცვლის მოვლენის მსმენელი)

დაყენება შესაძლებელია data-grizy- , new Gridzy() , setOptions() , Gridzy.setDefaultOptions() მეშვეობით

ინიციალიზაცია ხელით

// initialize a new Gridzy instance
var gridzyInstance = new Gridzy(document.querySelector('.gridzy'), {
  spaceBetween: 10,
  layout: 'waterfall'
});

გაანადგურე ინსტანცია

უხეშად რომ ვთქვათ, გრიდზის ინიციალიზაციის საპირისპირო.

gridzyInstance.destroy();
gridzyInstance = null;

ბავშვის სიის ხელით სინქრონიზაცია

// after child elements (images) are added to or removed from the DOM.
gridzyInstance.syncChildList();

ერთი ბავშვის ელემენტის ხელით სინქრონიზაცია

ჩვეულებრივ არ არის საჭირო, გარდა ძალიან იშვიათი შემთხვევებისა.

// after child elements (images) are added to the DOM and only one of them should be synced to Gridzy.
gridzyInstance.syncChild(childElement);

ატრიბუტების ხელით სინქრონიზაცია

გაითვალისწინეთ, რომ useOptionAttributes ვარიანტი უნდა იყოს true ამისათვის.

// after data-gridzy- attributes have changed
gridzyInstance.syncAttributes();

Force Rendering

ჩვეულებრივ არ არის საჭირო, მაშინაც კი, თუ ყველა ავტომატიზმი გამორთულია

gridzyInstance.render();