├── README.md
├── app
    ├── code
    │   └── community
    │   │   └── TM
    │   │       └── EasyTabs
    │   │           ├── Block
    │   │               ├── Abstract.php
    │   │               ├── Adminhtml
    │   │               │   ├── Edit.php
    │   │               │   ├── Edit
    │   │               │   │   ├── Form.php
    │   │               │   │   ├── Tab
    │   │               │   │   │   ├── Conditions.php
    │   │               │   │   │   └── Main.php
    │   │               │   │   └── Tabs.php
    │   │               │   ├── List.php
    │   │               │   ├── List
    │   │               │   │   └── Grid.php
    │   │               │   ├── Tab
    │   │               │   │   └── Options.php
    │   │               │   └── Widget
    │   │               │   │   └── Chosen.php
    │   │               ├── Product.php
    │   │               ├── Tab
    │   │               │   ├── Attribute.php
    │   │               │   ├── Cms.php
    │   │               │   ├── Html.php
    │   │               │   ├── Product
    │   │               │   │   ├── Additional.php
    │   │               │   │   ├── Description.php
    │   │               │   │   ├── Review.php
    │   │               │   │   └── Tags.php
    │   │               │   └── Template.php
    │   │               └── Widget.php
    │   │           ├── Controller
    │   │               └── Adminhtml
    │   │               │   └── Abstract.php
    │   │           ├── Helper
    │   │               └── Data.php
    │   │           ├── Model
    │   │               ├── Config
    │   │               │   ├── Layout.php
    │   │               │   ├── Status.php
    │   │               │   └── Tabs.php
    │   │               ├── Product
    │   │               │   └── Attribute
    │   │               │   │   └── Collection.php
    │   │               ├── Resource
    │   │               │   ├── Tab.php
    │   │               │   └── Tab
    │   │               │   │   └── Collection.php
    │   │               ├── Rule
    │   │               │   └── Condition
    │   │               │   │   ├── Combine.php
    │   │               │   │   └── Customer.php
    │   │               ├── Tab.php
    │   │               ├── Tabs.php
    │   │               └── Template
    │   │               │   └── Filter.php
    │   │           ├── controllers
    │   │               └── Adminhtml
    │   │               │   └── Easytabs
    │   │               │       ├── ProductController.php
    │   │               │       └── WidgetController.php
    │   │           ├── data
    │   │               └── easytabs_setup
    │   │               │   ├── data-upgrade-2.3.8-2.4.0.php
    │   │               │   └── data-upgrade-3.0.0-3.0.1.php
    │   │           ├── etc
    │   │               ├── adminhtml.xml
    │   │               ├── config.xml
    │   │               ├── easytabs.xml
    │   │               ├── system.xml
    │   │               ├── tmamp.xml
    │   │               └── widget.xml
    │   │           └── sql
    │   │               └── easytabs_setup
    │   │                   ├── upgrade-2.3.8-2.4.0.php
    │   │                   └── upgrade-3.0.3-3.1.0.php
    ├── design
    │   ├── adminhtml
    │   │   └── default
    │   │   │   └── default
    │   │   │       └── layout
    │   │   │           └── tm
    │   │   │               └── easytabs.xml
    │   └── frontend
    │   │   ├── base
    │   │       └── default
    │   │       │   ├── layout
    │   │       │       └── tm
    │   │       │       │   └── easytabs.xml
    │   │       │   └── template
    │   │       │       └── tm
    │   │       │           └── easytabs
    │   │       │               ├── tab
    │   │       │                   ├── catalog
    │   │       │                   │   └── product
    │   │       │                   │   │   ├── attribute.phtml
    │   │       │                   │   │   └── view
    │   │       │                   │   │       ├── attributes.phtml
    │   │       │                   │   │       └── description.phtml
    │   │       │                   ├── cms.phtml
    │   │       │                   ├── review
    │   │       │                   │   └── product
    │   │       │                   │   │   └── view
    │   │       │                   │   │       └── list.phtml
    │   │       │                   └── tag
    │   │       │                   │   └── product
    │   │       │                   │       └── list.phtml
    │   │       │               └── tabs.phtml
    │   │   └── tmamp
    │   │       └── default
    │   │           └── template
    │   │               └── tm
    │   │                   └── easytabs
    │   │                       └── tabs.phtml
    ├── etc
    │   └── modules
    │   │   └── TM_EasyTabs.xml
    └── locale
    │   ├── el_GR
    │       └── TM_EasyTabs.csv
    │   ├── en_US
    │       └── TM_EasyTabs.csv
    │   ├── es_ES
    │       └── TM_EasyTabs.csv
    │   ├── fr_FR
    │       └── TM_EasyTabs.csv
    │   ├── it_IT
    │       └── TM_EasyTabs.csv
    │   ├── nl_NL
    │       └── TM_EasyTabs.csv
    │   └── pt_PT
    │       └── TM_EasyTabs.csv
├── composer.json
├── modman
└── skin
    ├── adminhtml
        └── default
        │   └── default
        │       └── images
        │           └── widget
        │               ├── easytabs__widget.gif
        │               ├── easytabs__widget_2.gif
        │               └── easytabs__widget_transparent.png
    └── frontend
        └── base
            └── default
                └── tm
                    └── easytabs
                        ├── css
                            ├── styles.css
                            └── tmamp.scss
                        └── js
                            ├── main.js
                            ├── product.js
                            └── prototype.sticky-kit.js


/README.md:
--------------------------------------------------------------------------------
 1 | # Easy Tabs
 2 | Easy Tabs 3.0 - Magento Tabs extension for product page and any other page.
 3 | 
 4 |  -  show unlimited number of tabs on product page
 5 |  -  create your custom tabs and place them anywhere you want
 6 |  -  widget for Magento CMS
 7 |  -  responsive design, works fine on mobile devices
 8 |  -  unset blocks display in tab to avoid content duplication
 9 |  -  use custom templates for tab content
10 |  -  show other extensions content in tab using Custom Block tab
11 |  -  show number of reviews, tags, questions, etc by calling eval code in tab title
12 | 
13 | More details about Easy Tabs you can find at [documentation page](http://docs.swissuplabs.com/m1/extensions/easytabs/).
14 | Including configuration description and use cases.
15 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Abstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | abstract class TM_EasyTabs_Block_Abstract extends Mage_Core_Block_Template
  4 | {
  5 | 
  6 |     const PATTERN = '/{{.*?}}/si';
  7 | 
  8 |     protected $_tabs = array();
  9 | 
 10 |     protected $_objectToValidate = null;
 11 | 
 12 |     protected function _getCollection()
 13 |     {
 14 |         $collection = Mage::getModel('easytabs/tab')->getCollection();
 15 |         $storeId    = Mage::app()->getStore()->getStoreId();
 16 |         return $collection
 17 |             ->addStoreFilter($storeId)
 18 |             ->addFieldToFilter('status', array('eq' => 1))
 19 |             ->setOrder('sort_order', Varien_Data_Collection::SORT_ORDER_ASC);
 20 |     }
 21 | 
 22 |     protected function _prepareLayout()
 23 |     {
 24 |         if (!Mage::getStoreConfig('tm_easytabs/general/enabled')) {
 25 |             return parent::_prepareLayout();
 26 |         }
 27 | 
 28 |         $collection = $this->_getCollection();
 29 | 
 30 |         $filterTabs = $this->getFilterTabs();
 31 |         if (!empty($filterTabs)) {
 32 |             $filterTabs = str_replace(' ', '', $filterTabs);
 33 |             $filterTabs = explode(',', $filterTabs);
 34 |             $collection->addFieldToFilter('alias', array('in' => $filterTabs));
 35 |         }
 36 | 
 37 |         foreach ($collection as $tab) {
 38 | 
 39 |             if (!$tab->getConditions()->validate($this->getObjectToValidate()))
 40 |                 continue;
 41 | 
 42 |             $this->addTab(
 43 |                 $tab->getAlias(),
 44 |                 $tab->getTitle(),
 45 |                 $tab->getBlock(),
 46 |                 $tab->getTemplate(),
 47 |                 $tab->getData()
 48 |             );
 49 | 
 50 |             $unsets = (string) $tab->getUnset();
 51 |             $unsets = explode(',', $unsets);
 52 |             foreach ($unsets as $unset) {
 53 |                 if (false === strpos($unset, '::')) {
 54 |                     continue;
 55 |                 }
 56 |                 list($blockName, $alias) = explode('::', $unset);
 57 |                 $block = $this->getLayout()->getBlock($blockName);
 58 |                 if ($block) {
 59 |                     /**
 60 |                      * @see http://www.magentocommerce.com/bug-tracking/issue/index/id/142
 61 |                      * Call sortChildren before unset to fix Magento bug in
 62 |                      *     Mage_Core_Block_Abstract::sortChildren:
 63 |                      *  1. Unset drop the key from the _sortedChildren array
 64 |                      *  2. sortChildren method finds the block index to remove
 65 |                      *  3. sortChildren method uses array_splice wich reorder array
 66 |                      *      and previously founded block index become incorrect.
 67 |                      *
 68 |                      * The fix is works because sort is called only once.
 69 |                      * The correct way is to add the following line to
 70 |                      *     Mage_Core_Block_Abstract::unsetChild after
 71 |                      *     `unset($this->_sortedChildren[$key]);`:
 72 |                      *
 73 |                      *  $this->_sortedChildren = array_values($this->_sortedChildren);
 74 |                      */
 75 |                     $block->sortChildren();
 76 |                     $block->unsetChild($alias);
 77 |                 }
 78 |             }
 79 |         }
 80 |         return parent::_prepareLayout();
 81 |     }
 82 | 
 83 |     /**
 84 |      * @param string $title
 85 |      * @param string $block
 86 |      * @param string $template
 87 |      * @param array  $attributes
 88 |      */
 89 |     public function addTab($alias, $title, $block = false, $template = false, $attributes = array())
 90 |     {
 91 |         if (!$title || ($block && $block !== 'easytabs/tab_html' && !$template)) {
 92 |             return false;
 93 |         }
 94 | 
 95 |         if (!$block) {
 96 |             $block = $this->getLayout()->getBlock($alias);
 97 |             if (!$block) {
 98 |                 return false;
 99 |             }
100 |         } else {
101 |             // if (!Mage::registry('product') && strstr($block, 'product')) {
102 |             //     return false;
103 |             // }
104 | 
105 |             $block = $this->getLayout()
106 |                 ->createBlock($block, $alias, $attributes)
107 |                 ->setTemplate($template);
108 |         }
109 | 
110 |         $tab = array(
111 |             'alias' => $alias,
112 |             'title' => $title
113 |         );
114 | 
115 |         if (isset($attributes['sort_order'])) {
116 |             $tab['sort_order'] = $attributes['sort_order'];
117 |         }
118 | 
119 |         $this->_tabs[] = $tab;
120 | 
121 |         $this->setChild($alias, $block);
122 |     }
123 | 
124 |     protected function _sort($tab1, $tab2)
125 |     {
126 |         if (!isset($tab2['sort_order'])) {
127 |             return -1;
128 |         }
129 | 
130 |         if (!isset($tab1['sort_order'])) {
131 |             return 1;
132 |         }
133 | 
134 |         if ($tab1['sort_order'] == $tab2['sort_order']) {
135 |             return 0;
136 |         }
137 |         return ($tab1['sort_order'] < $tab2['sort_order']) ? -1 : 1;
138 |     }
139 | 
140 |     public function getTabs()
141 |     {
142 |         usort($this->_tabs, array($this, '_sort'));
143 |         return $this->_tabs;
144 |     }
145 | 
146 |     /**
147 |      * Check tab content for anything except html tags and spaces
148 |      *
149 |      * @param  string  $content
150 |      * @return boolean
151 |      */
152 |     public function isEmptyString($content)
153 |     {
154 |         $content = strip_tags(
155 |             $content,
156 |             '<hr><img><iframe><embed><object><video><audio><input><textarea><script><style><link><meta>'
157 |         );
158 |         $content = trim($content);
159 |         return strlen($content) === 0;
160 |     }
161 | 
162 |     public function getTabTitle($tab)
163 |     {
164 |         $args = array();
165 |         if (strstr($tab['title'], '{{') && strstr($tab['title'], '}}')) {
166 |             $scope = $this->getChild($tab['alias']);
167 |             /** @var TM_EasyTabs_Model_Template_Filter $processor **/
168 |             $processor = Mage::getModel('easytabs/template_filter')
169 |                 ->setScope($scope);
170 | 
171 |             preg_match_all(self::PATTERN, $tab['title'], $matches);
172 |             foreach ($matches[0] as $evalCode) {
173 |                 $tab['title'] = str_replace($evalCode, '%s', $tab['title']);
174 |                 $args[] = $processor->filter($evalCode);
175 |             }
176 |         }
177 |         array_unshift($args, $tab['title']);
178 | 
179 |         return call_user_func_array(array($this, "__"), $args);
180 |     }
181 | 
182 |     /**
183 |      * Returns show anchor flag
184 |      *
185 |      * @return boolean
186 |      */
187 |     public function getShowAnchor()
188 |     {
189 |         return Mage::getStoreConfigFlag('tm_easytabs/general/show_anchor');
190 |     }
191 | 
192 |     public function getHtmlId()
193 |     {
194 |         return 'easytabs';
195 |     }
196 | 
197 |     /**
198 |      * get object to check tabs conditions
199 |      * @return [type] [description]
200 |      */
201 |     public function getObjectToValidate()
202 |     {
203 |         if ($this->_objectToValidate === null) {
204 |             if (Mage::registry('product')) {
205 |                 $this->_objectToValidate = Mage::registry('product');
206 |             } else {
207 |                 $this->_objectToValidate = new Varien_Object();
208 |             }
209 |             $this->_objectToValidate->setCustomerGroup(
210 |                 Mage::getSingleton('customer/session')->getCustomerGroupId()
211 |             );
212 |         }
213 |         return $this->_objectToValidate;
214 |     }
215 | 
216 |     /**
217 |      * Check is tabs layout == expanded
218 |      *
219 |      * @return boolean
220 |      */
221 |     public function isExpandedLayout()
222 |     {
223 |         return $this->getTabsLayout() == TM_EasyTabs_Model_Config_Layout::LAYOUT_EXPANDED;
224 |     }
225 | }
226 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/Edit.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class TM_EasyTabs_Block_Adminhtml_Edit extends Mage_Adminhtml_Block_Widget_Form_Container
  4 | {
  5 |     public function __construct()
  6 |     {
  7 |         parent::__construct();
  8 | 
  9 |         $this->_blockGroup = 'easytabs';
 10 |         $this->_controller = 'adminhtml';
 11 | 
 12 |         $this->_addButton('saveandcontinue', array(
 13 |             'label'   => Mage::helper('adminhtml')->__('Save and Continue Edit'),
 14 |             'onclick' => 'saveAndContinueEdit()',
 15 |             'class'   => 'save'
 16 |         ), -100);
 17 |     }
 18 | 
 19 |     public function getHeaderText()
 20 |     {
 21 |         $data = Mage::registry('easytabs_tab');
 22 |         if ($data && $data->getId()) {
 23 |             return Mage::helper('easytabs')->__(
 24 |                 "Edit Tab # %s", $data->getTitle()
 25 |             );
 26 |         }
 27 |         return Mage::helper('easytabs')->__('Add New Tab');
 28 |     }
 29 | 
 30 |     /**
 31 |      * Prepare Layout Content
 32 |      *
 33 |      * @return TM_EasyTabs_Block_Adminhtml_Edit
 34 |      */
 35 |     protected function _prepareLayout()
 36 |     {
 37 |         if (Mage::getSingleton('cms/wysiwyg_config')->isEnabled()) {
 38 |             $this->getLayout()->getBlock('head')->setCanLoadTinyMce(true);
 39 |         }
 40 | 
 41 |         $model  = Mage::registry('easytabs_tab');
 42 |         $values = $model->getData();
 43 |         unset($values['conditions_serialized']);
 44 |         $values = isset($values['id']) ? Mage::helper('core')->jsonEncode($values) : 'false';
 45 |         $this->_formScripts[] = "
 46 |             function saveAndContinueEdit(){
 47 |                 editForm.submit($('edit_form').action + 'back/1');
 48 |             }
 49 | 
 50 |             EasytabsTabOptions = function() {
 51 |                 var _values = {$values},
 52 |                 _url = '{$this->getUrl('*/*/loadTabOptions')}';
 53 | 
 54 |                 function _insertHtml(html) {
 55 |                     var container = $('widget_options');
 56 |                     if (!container) {
 57 |                         $('easytabs_tabs_main_section_content').insert({
 58 |                             bottom: '<div id=\"widget_options\"></div>'
 59 |                         });
 60 |                     }
 61 |                     $('widget_options').innerHTML = html;
 62 |                 }
 63 |                 return {
 64 |                     load: function(type) {
 65 |                         var params = {widget_type: type};
 66 |                         if (_values && _values['block'] == type) {
 67 |                             params['values'] = _values;
 68 |                         }
 69 |                         new Ajax.Request(_url, {
 70 |                             parameters: {widget: Object.toJSON(params)},
 71 |                             onSuccess: function(transport) {
 72 |                                 try {
 73 |                                     _insertHtml(transport.responseText);
 74 |                                 } catch(e) {
 75 |                                     alert(e.message);
 76 |                                 }
 77 |                             }.bind(this)
 78 |                         });
 79 |                     }
 80 |                 }
 81 |             }();
 82 | 
 83 |             $('block_type').observe('change', function(event) {
 84 |                 var value = $(this).getValue();
 85 |                 EasytabsTabOptions.load(value);
 86 |                 $('block').setValue(value);
 87 |             });
 88 |             EasytabsTabOptions.load($('block_type').getValue());
 89 | 
 90 |             Validation.add('validate-data', 'Use only letters (a-z or A-Z), numbers (0-9), underscore(_) or period (.) in this field and starts with a letter.', function (v) {
 91 |                 if(v != '' && v) {
 92 |                     return /^[A-Za-z]+[A-Za-z0-9_.-]+$/.test(v);
 93 |                 }
 94 |                 return true;
 95 |             });
 96 |         ";
 97 | 
 98 |         return parent::_prepareLayout();
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/Edit/Form.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Adminhtml_Edit_Form extends Mage_Adminhtml_Block_Widget_Form
 4 | {
 5 |     protected function _prepareForm()
 6 |     {
 7 |         $form = new Varien_Data_Form(array(
 8 |             'id' => 'edit_form',
 9 |             'action' => $this->getUrl('*/*/save'),
10 |             'method' => 'post',
11 |             'enctype' => 'multipart/form-data'
12 |         ));
13 | 
14 |         $form->setUseContainer(true);
15 |         $this->setForm($form);
16 |         return parent::_prepareForm();
17 |     }
18 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/Edit/Tab/Conditions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Adminhtml_Edit_Tab_Conditions
 4 |     extends Mage_Adminhtml_Block_Widget_Form
 5 |     implements Mage_Adminhtml_Block_Widget_Tab_Interface
 6 | {
 7 | 
 8 |     /**
 9 |      * Prepare label for tab
10 |      *
11 |      * @return string
12 |      */
13 |     public function getTabLabel()
14 |     {
15 |         return $this->__('Conditions');
16 |     }
17 | 
18 |     /**
19 |      * Prepare title for tab
20 |      *
21 |      * @return string
22 |      */
23 |     public function getTabTitle()
24 |     {
25 |         return $this->__('Conditions');
26 |     }
27 | 
28 |     public function isHidden()
29 |     {
30 |         return false;
31 |     }
32 | 
33 |     /**
34 |      * Returns status flag about this tab can be showen or not
35 |      *
36 |      * @return true
37 |      */
38 |     public function canShowTab()
39 |     {
40 |         return true;
41 |     }
42 | 
43 |     /**
44 |      * Getter
45 |      *
46 |      * @return TM_SeoTemplates_Model_Template
47 |      */
48 |     public function getEasytabsTab()
49 |     {
50 |         return Mage::registry('easytabs_tab');
51 |     }
52 | 
53 |     /**
54 |      * Prepare form before rendering HTML
55 |      *
56 |      * @return Mage_Widget_Block_Adminhtml_Widget_Instance_Edit_Tab_Settings
57 |      */
58 |     protected function _prepareForm()
59 |     {
60 |         $easytab = $this->getEasytabsTab();
61 |         $form = new Varien_Data_Form();
62 | 
63 |         $renderer = Mage::getBlockSingleton('adminhtml/widget_form_renderer_fieldset')
64 |             ->setTemplate('promo/fieldset.phtml')
65 |             ->setNewChildUrl($this->getUrl('*/*/newConditionHtml/form/conditions_fieldset'));
66 | 
67 |         $fieldset = $form->addFieldset('conditions_fieldset', array(
68 |             'legend'=>$this->__('Conditions (leave blank to apply for all)'))
69 |         )->setRenderer($renderer);
70 | 
71 |         $fieldset->addField('conditions', 'text', array(
72 |             'name' => 'conditions',
73 |             'label' => $this->__('Conditions'),
74 |             'title' => $this->__('Conditions'),
75 |         ))->setRule($easytab)
76 |         ->setRenderer(Mage::getBlockSingleton('rule/conditions'));
77 | 
78 |         $this->setForm($form);
79 | 
80 |         return parent::_prepareForm();
81 |     }
82 | 
83 |     /**
84 |      * Initialize form fileds values
85 |      *
86 |      * @return TM_SeoTemplates_Block_Adminhtml_List_Edit_Tab_Main
87 |      */
88 |     protected function _initFormValues()
89 |     {
90 |         $this->getForm()->addValues($this->getEasytabsTab()->getData());
91 |         return parent::_initFormValues();
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/Edit/Tab/Main.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class TM_EasyTabs_Block_Adminhtml_Edit_Tab_Main
  4 |     extends Mage_Adminhtml_Block_Widget_Form
  5 |         implements Mage_Adminhtml_Block_Widget_Tab_Interface
  6 | {
  7 |     protected function _getBlockTypes($productTab)
  8 |     {
  9 |         $tabs = Mage::getSingleton('easytabs/tabs')->getTabsArray();
 10 |         // var_dump($tabs);die;
 11 |         $types = array();
 12 |         foreach ($tabs as $tab) {
 13 |             if (!in_array($tab['code'], array('cms', 'template', 'html')) && !$productTab) {
 14 |                 continue;
 15 |             }
 16 |             $types[$tab['type']] = $tab['name'];
 17 |         }
 18 |         return $types;
 19 |     }
 20 | 
 21 | 
 22 |     protected function _prepareForm()
 23 |     {
 24 |         $model = Mage::registry('easytabs_tab');
 25 | 
 26 |         $form  = new Varien_Data_Form();
 27 | 
 28 |         $this->setForm($form);
 29 | 
 30 |         $fieldset = $form->addFieldset(
 31 |             'trap_general_form',
 32 |             array('legend' => Mage::helper('easytabs')->__('General Details'))
 33 |         );
 34 | 
 35 |         if ($model->getId()) {
 36 |             $fieldset->addField('id', 'hidden', array(
 37 |                 'name' => 'id',
 38 |             ));
 39 |         }
 40 | 
 41 |         $fieldset->addField('product_tab', 'hidden', array(
 42 |                 'name' => 'product_tab',
 43 |             ));
 44 | 
 45 |         $fieldset->addField('title', 'text', array(
 46 |             'label'    => Mage::helper('easytabs')->__('Title'),
 47 |             'class'    => 'required-entry',
 48 |             'required' => true,
 49 |             'name'     => 'title',
 50 |         ));
 51 | 
 52 |         $fieldset->addField('alias', 'text', array(
 53 |             'label'    => Mage::helper('easytabs')->__('Alias'),
 54 |             'class'    => 'required-entry',
 55 |             'required' => true,
 56 |             'class'    => 'validate-data',
 57 |             'name'     => 'alias',
 58 |         ));
 59 | 
 60 |         $block = $model->getBlock();
 61 |         $blockTypes = $this->_getBlockTypes($model->getProductTab());
 62 |         if (!isset($blockTypes[$block])) {
 63 |             $model->setBlock('easytabs/tab_html');
 64 |         }
 65 |         $model->setBlockType($model->getBlock());
 66 | 
 67 |         $fieldset->addField('block_type', 'select', array(
 68 |             'label'   => Mage::helper('easytabs')->__('Block Type'),
 69 |             'title'   => Mage::helper('easytabs')->__('Block Type'),
 70 |             'name'    => 'block_type',
 71 |             'options' => $blockTypes,
 72 |         ));
 73 | 
 74 |         $fieldset->addField('block', 'text', array(
 75 |             'label'    => Mage::helper('easytabs')->__('Block'),
 76 |             'class'    => 'required-entry',
 77 |             'required' => true,
 78 |             'disabled' => true,
 79 |             'name'     => 'block',
 80 |         ));
 81 | 
 82 |         $sortOrder = $model->getSortOrder();
 83 |         if (empty($sortOrder)) {
 84 |             $model->setSortOrder(0);
 85 |         }
 86 |         $fieldset->addField('sort_order', 'text', array(
 87 |             'label' => Mage::helper('easytabs')->__('Sort Order'),
 88 |             'name'  => 'sort_order',
 89 |             'class' => 'validate-digits',
 90 |         ));
 91 | 
 92 |         $fieldset->addField('status', 'select', array(
 93 |             'label'    => Mage::helper('easytabs')->__('Status'),
 94 |             'title'    => Mage::helper('easytabs')->__('Status'),
 95 |             'name'     => 'status',
 96 |             'required' => true,
 97 |             'options'  => Mage::getSingleton('easytabs/config_status')->toOptionHash(),
 98 |         ));
 99 |         if (!$model->getId()) {
100 |             $model->setData('status', '1');
101 |         }
102 | 
103 |         if (!Mage::app()->isSingleStoreMode()) {
104 |             $field = $fieldset->addField('store_id', 'multiselect', array(
105 |                 'name'     => 'stores[]',
106 |                 'label'    => Mage::helper('checkout')->__('Store View'),
107 |                 'title'    => Mage::helper('checkout')->__('Store View'),
108 |                 'required' => true,
109 |                 'values'   => Mage::getSingleton('adminhtml/system_store')->getStoreValuesForForm(false, true),
110 |             ));
111 |             $renderer = $this->getLayout()->createBlock('adminhtml/store_switcher_form_renderer_fieldset_element');
112 |             if ($renderer) {
113 |                 $field->setRenderer($renderer);
114 |             }
115 |         } else {
116 |             $fieldset->addField('store_id', 'hidden', array(
117 |                 'name'  => 'store_id',
118 |                 'value' => Mage::app()->getStore(true)->getId()
119 |             ));
120 |             $model->setStoreId(Mage::app()->getStore(true)->getId());
121 |         }
122 | 
123 |         $form->setValues($model->getData());
124 | 
125 |         return parent::_prepareForm();
126 |     }
127 | 
128 |     /**
129 |      * Prepare label for tab
130 |      *
131 |      * @return string
132 |      */
133 |     public function getTabLabel()
134 |     {
135 |         return Mage::helper('easytabs')->__('Main');
136 |     }
137 | 
138 |     /**
139 |      * Prepare title for tab
140 |      *
141 |      * @return string
142 |      */
143 |     public function getTabTitle()
144 |     {
145 |         return Mage::helper('easytabs')->__('Main');
146 |     }
147 | 
148 |     /**
149 |      * Returns status flag about this tab can be shown or not
150 |      *
151 |      * @return true
152 |      */
153 |     public function canShowTab()
154 |     {
155 |         return true;
156 |     }
157 | 
158 |     /**
159 |      * Returns status flag about this tab hidden or not
160 |      *
161 |      * @return true
162 |      */
163 |     public function isHidden()
164 |     {
165 |         return false;
166 |     }
167 | }
168 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/Edit/Tabs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Adminhtml_Edit_Tabs extends Mage_Adminhtml_Block_Widget_Tabs
 4 | {
 5 |     public function __construct()
 6 |     {
 7 |         parent::__construct();
 8 |         $this->setId('easytabs_tabs');
 9 |         $this->setDestElementId('edit_form');
10 |         $this->setTitle(Mage::helper('easytabs')->__('Tab Information'));
11 |     }
12 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/List.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Adminhtml_List extends Mage_Adminhtml_Block_Widget_Grid_Container
 4 | {
 5 |     public function __construct()
 6 |     {
 7 | 
 8 |         $this->_blockGroup = 'easytabs';
 9 |         $this->_controller = 'adminhtml_list';
10 | 
11 |         parent::__construct();
12 |     }
13 | 
14 |     protected function _beforeToHtml()
15 |     {
16 |         $this->_headerText = Mage::helper('easytabs')->__($this->getTitle());
17 |         return parent::_beforeToHtml();
18 |     }
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/List/Grid.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class TM_EasyTabs_Block_Adminhtml_List_Grid extends Mage_Adminhtml_Block_Widget_Grid
  4 | {
  5 |     public function __construct()
  6 |     {
  7 |         parent::__construct();
  8 |         $this->setId('easytabsGrid');
  9 |         $this->setDefaultSort('name');
 10 |         $this->setDefaultDir('ASC');
 11 |         $this->setSaveParametersInSession(true);
 12 |     }
 13 | 
 14 |     protected function _prepareCollection()
 15 |     {
 16 |         $collection = Mage::getModel('easytabs/tab')->getCollection();
 17 | 
 18 |         $blockList = $this->getLayout()->getBlock('easytabs_list');
 19 |         if ($blockList) {
 20 |             if ($blockList->getProductTab()) {
 21 |                 $collection->addProductTabFilter();
 22 |             } else {
 23 |                 $collection->addWidgetTabFilter();
 24 |             }
 25 |         }
 26 | 
 27 |         $this->setCollection($collection);
 28 |         return parent::_prepareCollection();
 29 |     }
 30 | 
 31 |     protected function _prepareColumns()
 32 |     {
 33 |         $this->addColumn('id', array(
 34 |           'header'    => Mage::helper('easytabs')->__('ID'),
 35 |           'align'     =>'right',
 36 |           // 'width'     => '50px',
 37 |           'index'     => 'id',
 38 |           'type'      => 'number'
 39 |         ));
 40 |         $this->addColumn('title', array(
 41 |             'header'    => Mage::helper('easytabs')->__('Title'),
 42 |             'align'     => 'left',
 43 |             'index'     => 'title',
 44 |         ));
 45 | 
 46 |         $this->addColumn('alias', array(
 47 |             'header'    => Mage::helper('easytabs')->__('Alias'),
 48 |             'index'     => 'alias',
 49 |         ));
 50 | 
 51 |         $this->addColumn('block', array(
 52 |             'header'    => Mage::helper('easytabs')->__('Block'),
 53 |             'align'     => 'left',
 54 |             'index'     => 'block',
 55 |         ));
 56 | 
 57 |         $this->addColumn('sort_order', array(
 58 |             'header'    => Mage::helper('easytabs')->__('Sort Order'),
 59 |             'align'     =>'right',
 60 |             'width'     => '50px',
 61 |             'index'     => 'sort_order',
 62 |             'type'      => 'number'
 63 |         ));
 64 | 
 65 |         $this->addColumn('status', array(
 66 |             'header'    => Mage::helper('easytabs')->__('Status'),
 67 |             'align'     => 'left',
 68 |             'width'     => '80px',
 69 |             'index'     => 'status',
 70 |             'type'      => 'options',
 71 |             'options'   => Mage::getSingleton('easytabs/config_status')->toOptionHash(),
 72 |         ));
 73 |         if (!Mage::app()->isSingleStoreMode()) {
 74 | 
 75 |             $this->addColumn('store_id', array(
 76 |                 'header'     => Mage::helper('cms')->__('Store View'),
 77 |                 'index'      => 'store_id',
 78 |                 'type'       => 'store',
 79 |                 'store_all'  => true,
 80 |                 'store_view' => true,
 81 |                 'sortable'   => false,
 82 |                 'filter_condition_callback'
 83 |                                 => array($this, '_filterStoreCondition'),
 84 |             ));
 85 |         }
 86 | 
 87 |         return parent::_prepareColumns();
 88 |     }
 89 | 
 90 |     public function getRowUrl($row)
 91 |     {
 92 |         return $this->getUrl('*/*/edit', array('id' => $row->getId()));
 93 |     }
 94 | 
 95 |     protected function _prepareMassaction()
 96 |     {
 97 |         $this->setMassactionIdField('entity_id');
 98 |         $this->getMassactionBlock()->setFormFieldName('easytabs');
 99 | 
100 |         $this->getMassactionBlock()->addItem('delete', array(
101 |              'label'    => Mage::helper('easytabs')->__('Delete'),
102 |              'url'      => $this->getUrl('*/*/massDelete'),
103 |              'confirm'  => Mage::helper('easytabs')->__('Are you sure?')
104 |         ));
105 | 
106 |         $statuses = Mage::getSingleton('easytabs/config_status')->toOptionArray();
107 | 
108 |         array_unshift($statuses, array('label'=>'', 'value'=>''));
109 |         $this->getMassactionBlock()->addItem('status', array(
110 |             'label'=> Mage::helper('easytabs')->__('Change status'),
111 |             'url' => $this->getUrl('*/*/massStatus', array('_current'=>true)),
112 |             'additional' => array(
113 |                 'visibility' => array(
114 |                     'name'   => 'status',
115 |                     'type'   => 'select',
116 |                     'class'  => 'required-entry',
117 |                     'label'  => Mage::helper('easytabs')->__('Status'),
118 |                     'values' => $statuses
119 |                 )
120 |             )
121 |         ));
122 | 
123 |         return $this;
124 |     }
125 | 
126 |     protected function _afterLoadCollection()
127 |     {
128 |         $this->getCollection()->walk('afterLoad');
129 |         parent::_afterLoadCollection();
130 |     }
131 | 
132 |     protected function _filterStoreCondition($collection, $column)
133 |     {
134 |         if (!$value = $column->getFilter()->getValue()) {
135 |             return;
136 |         }
137 |         $this->getCollection()->addStoreFilter($value);
138 |     }
139 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/Tab/Options.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Adminhtml_Tab_Options extends Mage_Widget_Block_Adminhtml_Widget_Options
 4 | {
 5 |     /**
 6 |      * Add fields to main fieldset based on specified tab type
 7 |      *
 8 |      * @return Mage_Adminhtml_Block_Widget_Form
 9 |      */
10 |     public function addFields()
11 |     {
12 |         // get configuration node and translation helper
13 |         if (!$this->getWidgetType()) {
14 |             Mage::throwException($this->__('Widget Type is not specified'));
15 |         }
16 |         $config = Mage::getSingleton('easytabs/tabs')->getConfigAsObject($this->getWidgetType());
17 |         if (!$config->getParameters()) {
18 |             return $this;
19 |         }
20 |         $module = $config->getModule();
21 |         $this->_translationHelper = Mage::helper($module ? $module : 'widget');
22 |         foreach ($config->getParameters() as $parameter) {
23 |             $this->_addField($parameter);
24 |         }
25 | 
26 |         return $this;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Adminhtml/Widget/Chosen.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Adminhtml_Widget_Chosen
 4 |     extends Mage_Adminhtml_Block_Widget
 5 | {
 6 | 
 7 |     /**
 8 |      * Prepare chooser element HTML
 9 |      *
10 |      * @param Varien_Data_Form_Element_Abstract $element Form Element
11 |      * @return Varien_Data_Form_Element_Abstract
12 |      */
13 |     public function prepareElementHtml(Varien_Data_Form_Element_Abstract $element)
14 |     {
15 |         $html = <<<HTML
16 | <script type="text/javascript">
17 |     new Chosen(
18 |         $("{$element->getId()}"),
19 |         {width: "280px", placeholder_text: "{$this->__('Select Tabs')}"});
20 |     $("{$element->getId()}")
21 |         .up(".entry-edit .fieldset .hor-scroll")
22 |         .setStyle({overflow: "visible"});
23 |     if ($("{$element->getId()}").up("#widget_window_content")) {
24 |         $("{$element->getId()}")
25 |             .up("#widget_window_content")
26 |             .setStyle({overflow: "visible"})
27 |             .up("#widget_window_table_content")
28 |             .setStyle({overflow: "visible"});
29 |     }
30 | </script>
31 | HTML;
32 |         $element->setData('after_element_html', $html);
33 |         return $element;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Product.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Product extends TM_EasyTabs_Block_Abstract
 4 | {
 5 | 
 6 |     protected function _getCollection()
 7 |     {
 8 |         return parent::_getCollection()->addProductTabFilter();
 9 |     }
10 | 
11 |     /**
12 |      * Returns show anchor flag
13 |      *
14 |      * @return boolean
15 |      */
16 |     public function getUpdateUrlHash()
17 |     {
18 |         return Mage::getStoreConfigFlag('tm_easytabs/general/update_url_hash');
19 |     }
20 | 
21 |     public function getHtmlId()
22 |     {
23 |         return 'easytabs-product';
24 |     }
25 | 
26 |     /**
27 |      * Get product tabs layout name
28 |      *
29 |      * @return string
30 |      */
31 |     public function getTabsLayout()
32 |     {
33 |         return Mage::getStoreConfig('tm_easytabs/general/tabs_layout');
34 |     }
35 | 
36 |     public function getStickyTabs()
37 |     {
38 |         return Mage::getStoreConfigFlag('tm_easytabs/general/sticky_tabs');
39 |     }
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Attribute.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class TM_EasyTabs_Block_Tab_Attribute extends Mage_Catalog_Block_Product_View
4 | {
5 |     public function getAttributeCode()
6 |     {
7 |         return $this->getCustomOption();
8 |     }
9 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Cms.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class TM_EasyTabs_Block_Tab_Cms extends Mage_Core_Block_Template
4 | {
5 |     public function getCmsBlockId()
6 |     {
7 |         return $this->getCustomOption();
8 |     }
9 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Html.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Tab_Html extends Mage_Core_Block_Abstract
 4 | {
 5 |     protected function _toHtml()
 6 |     {
 7 |         $processor = Mage::helper('cms')->getBlockTemplateProcessor();
 8 |         return $processor->filter($this->getContent());
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Product/Additional.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Tab_Product_Additional
 4 |     extends Mage_Catalog_Block_Product_View_Attributes
 5 | {
 6 | 
 7 |     protected function _construct()
 8 |     {
 9 |         parent::_construct();
10 |         $this->setData(
11 |             'is_grouped',
12 |             Mage::getStoreConfig('tm_easytabs/general/group_attributes')
13 |         );
14 |     }
15 | 
16 |     public function getAdditionalData(array $excludeAttr = array())
17 |     {
18 |         $_additional = parent::getAdditionalData($excludeAttr);
19 | 
20 |         if ($this->getIsGrouped()) {
21 |             $setId = $this->getProduct()->getAttributeSetId(); // Attr Set Id
22 |             $groups = Mage::getModel('eav/entity_attribute_group')
23 |                 ->getResourceCollection()
24 |                 ->setAttributeSetFilter($setId)
25 |                 ->setSortOrder()
26 |                 ->load();
27 | 
28 |             $attributeCodes = array();
29 |             foreach ($groups as $group) {
30 |                 $groupName = $group->getAttributeGroupName();
31 |                 $groupId = $group->getAttributeGroupId();
32 | 
33 |                 $attributes = Mage::getResourceModel('catalog/product_attribute_collection')
34 |                     ->setAttributeGroupFilter($group->getId())
35 |                     ->addVisibleFilter()
36 |                     ->checkConfigurableProducts()
37 |                     ->load();
38 |                 if ($attributes->getSize() > 0) {
39 |                     foreach ($attributes->getItems() as $attribute) {
40 |                         /* @var $child Mage_Eav_Model_Entity_Attribute */
41 |                         $attributeCodes[$attribute->getAttributeCode()] = array(
42 |                             'id' => $groupId,
43 |                             'name' => $groupName,
44 |                             'sort_order' => $group->getSortOrder()
45 |                         );
46 |                         // uncomment for debug
47 |                         // if ($attribute->getIsVisibleOnFront() && $attribute->getIsUserDefined()) {
48 |                             // $_additional[$attribute->getAttributeCode()] = array(
49 |                             //     "label" => $attribute->getFrontendLabel(),
50 |                             //     "value" => $attribute->getDefaultValue() . ' xx',
51 |                             //     "code" => $attribute->getAttributeCode()
52 |                             // );
53 |                         // }
54 |                     }
55 |                 }
56 |             }
57 | 
58 |             foreach ($_additional as &$data) {
59 |                 $data['group'] = isset($attributeCodes[$data['code']])
60 |                     ? $attributeCodes[$data['code']]
61 |                     : array();
62 |             }
63 |             usort($_additional, function($a, $b) {
64 |                 return $a['group']['sort_order'] - $b['group']['sort_order'];
65 |             });
66 |         }
67 | 
68 |         return $_additional;
69 |     }
70 | 
71 | }
72 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Product/Description.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class TM_EasyTabs_Block_Tab_Product_Description
4 |     extends Mage_Catalog_Block_Product_View_Description
5 | {
6 | }
7 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Product/Review.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Tab_Product_Review extends Mage_Review_Block_Product_View_List
 4 | {
 5 |     protected function _prepareLayout()
 6 |     {
 7 |         $reviewForm = $this->getLayout()->createBlock('review/form', 'product.review.form');
 8 |         if ($reviewForm) {
 9 |             $wrapper = $this->getLayout()
10 |                 ->createBlock('page/html_wrapper', 'product.review.form.fields.before');
11 |             if ($wrapper) {
12 |                 $wrapper->setMayBeInvisible(1);
13 |                 $reviewForm->setChild('form_fields_before', $wrapper);
14 |             }
15 |             $this->setChild('review_form', $reviewForm);
16 |         }
17 |         return parent::_prepareLayout();
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Product/Tags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Tab_Product_Tags extends Mage_Tag_Block_Product_List
 4 | {
 5 |     protected function _prepareLayout()
 6 |     {
 7 |         $wrapper = $this->getLayout()->getBlock('product.tag.list.list.before');
 8 |         if ($wrapper) {
 9 |             $this->setChild('list_before', $wrapper);
10 |         }
11 |         return parent::_prepareLayout();
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Tab/Template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Tab_Template extends Mage_Core_Block_Template
 4 | {
 5 |     protected function _prepareLayout()
 6 |     {
 7 |         $block = $this->getLayout()->createBlock(
 8 |             $this->getCustomOption(), $this->getNameInLayout() . '_tab'
 9 |         );
10 |         if ($block instanceof Mage_Core_Block_Template) {
11 |             $this->setChild($this->getNameInLayout() . '_tab', $block);
12 |         }
13 |         return parent::_prepareLayout();
14 |     }
15 | 
16 |     protected function _toHtml()
17 |     {
18 |         $block = $this->getTabBlock();
19 |         if ($block instanceof Mage_Core_Block_Template) {
20 |             return $block->setTemplate($this->getTemplate())
21 |                 ->toHtml();
22 |         }
23 |         return '';
24 |     }
25 | 
26 |     public function getTabBlock()
27 |     {
28 |         return $this->getChild($this->getNameInLayout() . '_tab');
29 |     }
30 | 
31 |     public function getCount()
32 |     {
33 |         $block = $this->getTabBlock();
34 |         if ($block instanceof Mage_Core_Block_Template) {
35 |             return $block->getCount();
36 |         }
37 |         return;
38 |     }
39 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Block/Widget.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Block_Widget extends TM_EasyTabs_Block_Abstract implements Mage_Widget_Block_Interface
 4 | {
 5 | 
 6 |     protected function _getCollection()
 7 |     {
 8 |         $collection = parent::_getCollection()->addWidgetTabFilter();
 9 |         $filterTabs = $this->getFilterTabs();
10 |         if (!empty($filterTabs)) {
11 |             $filterTabs = str_replace(' ', '', $filterTabs);
12 |             $filterTabs = explode(',', $filterTabs);
13 |             $collection->addFieldToFilter('alias', array('in' => $filterTabs));
14 |         }
15 |         return $collection;
16 |     }
17 | 
18 |     /**
19 |      * Returns show anchor flag
20 |      *
21 |      * @return boolean
22 |      */
23 |     public function getUpdateUrlHash()
24 |     {
25 |         return 0;
26 |     }
27 | 
28 |     public function getHtmlId()
29 |     {
30 |         if (!$this->getData('html_id')) {
31 |             $htmlId = 'easytabs-widget-';
32 |             foreach ($this->_getCollection() as $tab) {
33 |                 $htmlId .= $tab->getId();
34 |             }
35 |             $this->setData('html_id', $htmlId);
36 |         }
37 |         return $this->getData('html_id');
38 |     }
39 | 
40 | }
41 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Controller/Adminhtml/Abstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | abstract class TM_EasyTabs_Controller_Adminhtml_Abstract
  4 |     extends Mage_Adminhtml_Controller_Action
  5 | {
  6 | 
  7 |     protected $productTab = 0;
  8 | 
  9 |     protected function _initAction()
 10 |     {
 11 |         $this->loadLayout();
 12 |         $this->_setActiveMenu('templates_master/easytabs')
 13 |             ->_addBreadcrumb(
 14 |                 Mage::helper('easytabs')->__('easytabs'),
 15 |                 Mage::helper('easytabs')->__('easytabs')
 16 |             );
 17 | 
 18 |         return $this;
 19 |     }
 20 | 
 21 |     public function indexAction()
 22 |     {
 23 |         $this->_initAction();
 24 |         $this->renderLayout();
 25 |     }
 26 | 
 27 |     public function newAction()
 28 |     {
 29 |         $this->_forward('edit');
 30 |     }
 31 | 
 32 |     public function editAction()
 33 |     {
 34 | 
 35 |         // 1. Get ID and create model
 36 |         $id = $this->getRequest()->getParam('id');
 37 |         $model = Mage::getModel('easytabs/tab');
 38 | 
 39 |         // 2. Initial checking
 40 |         if ($id) {
 41 |             $model->load($id);
 42 |             if (!$model->getId()) {
 43 |                 Mage::getSingleton('adminhtml/session')->addError(
 44 |                     Mage::helper('easytabs')
 45 |                         ->__('This tab no longer exists.'));
 46 |                 $this->_redirect('*/*/');
 47 |                 return;
 48 |             }
 49 |         } else {
 50 |             // set flag `product tab`
 51 |             $model->setProductTab($this->productTab);
 52 |         }
 53 | 
 54 |         if ($model->getId()) {
 55 |             $this->_title(Mage::helper('easytabs')->__('Edit Tab'));
 56 |         } else {
 57 |             $this->_title(Mage::helper('easytabs')->__('New Tab'));
 58 |         }
 59 | 
 60 |         // 3. Set entered data if was error when we do save
 61 |         $data = Mage::getSingleton('adminhtml/session')->getFormData(true);
 62 |         if (! empty($data)) {
 63 |             $model->setData($data);
 64 |         }
 65 | 
 66 |         // 4. Register model to use later in blocks
 67 |         Mage::register('easytabs_tab', $model);
 68 | 
 69 | 
 70 |         $this->_initAction();
 71 |         $this->renderLayout();
 72 |     }
 73 | 
 74 |     public function saveAction()
 75 |     {
 76 |         // check if data sent
 77 |         if ($data = $this->getRequest()->getPost()) {
 78 | 
 79 |             if (isset($data['rule']['conditions'])) {
 80 |                 $data['conditions'] = $data['rule']['conditions'];
 81 |                 unset($data['rule']);
 82 |             }
 83 | 
 84 |             //init model and set data
 85 |             $model = Mage::getModel('easytabs/tab');
 86 |             if ($id = $this->getRequest()->getParam('id')) {
 87 |                 $model->load($id);
 88 |             }
 89 | 
 90 |             // $model->setData($data);
 91 |             $model->loadPost($data);
 92 |             foreach ($data['parameters'] as $key => $value) {
 93 |                 $model->setData($key, $value);
 94 |             }
 95 | 
 96 |             // try to save blacklist rule
 97 |             try {
 98 |                 // save the data
 99 |                 $model->save();
100 |                 // display success message
101 |                 Mage::getSingleton('adminhtml/session')->addSuccess(
102 |                     Mage::helper('easytabs')->__(
103 |                         'Tab \'%s\' has been saved.',
104 |                         $model->getTitle()
105 |                     )
106 |                 );
107 |                 // clear previously saved data from session
108 |                 Mage::getSingleton('adminhtml/session')->setFormData(false);
109 |                 // check if 'Save and Continue'
110 |                 if ($this->getRequest()->getParam('back')) {
111 |                     $this->_redirect(
112 |                         '*/*/edit',
113 |                         array(
114 |                             'id' => $model->getId(),
115 |                             '_current'=>true
116 |                         )
117 |                     );
118 |                     return;
119 |                 }
120 |                 // go to grid
121 |                 $this->_redirect('*/*/');
122 |                 return;
123 |             } catch (Mage_Core_Exception $e) {
124 |                 $this->_getSession()->addError($e->getMessage());
125 |             }
126 |             catch (Exception $e) {
127 |                 $this->_getSession()->addException(
128 |                     $e,
129 |                     $this->__('An error occurred while saving.')
130 |                 );
131 |             }
132 |             $this->_getSession()->setFormData($data);
133 |             $this->_redirect(
134 |                 '*/*/edit',
135 |                 array('id' => $this->getRequest()->getParam('id'))
136 |             );
137 |             return;
138 |         }
139 |         $this->_redirect('*/*/');
140 |     }
141 | 
142 |     /**
143 |      * Overriden Mage_Adminhtml_Catalog_CategoryController::wysiwygAction
144 |      * Changed block type to allow to use widgets
145 |      */
146 |     public function wysiwygAction()
147 |     {
148 |         $elementId = $this->getRequest()->getParam('element_id', sha1(microtime()));
149 |         $storeId = $this->getRequest()->getParam('store_id', 0);
150 |         $storeMediaUrl = Mage::app()->getStore($storeId)->getBaseUrl(Mage_Core_Model_Store::URL_TYPE_MEDIA);
151 | 
152 |         $content = $this->getLayout()->createBlock(
153 |             'tmcore/adminhtml_widget_form_element_wysiwyg_content',
154 |             '',
155 |             array(
156 |                 'editor_element_id' => $elementId,
157 |                 'store_id'          => $storeId,
158 |                 'store_media_url'   => $storeMediaUrl,
159 |             )
160 |         );
161 | 
162 |         $this->getResponse()->setBody($content->toHtml());
163 |     }
164 | 
165 |     /**
166 |      * Delete action
167 |      */
168 |     public function deleteAction()
169 |     {
170 |         // check if we know what should be deleted
171 |         if ($id = $this->getRequest()->getParam('id')) {
172 |             try {
173 |                 // init model and delete
174 |                 $model = Mage::getModel('easytabs/tab');
175 |                 $model->load($id);
176 |                 $model->delete();
177 |                 // display success message
178 |                 Mage::getSingleton('adminhtml/session')->addSuccess(
179 |                     $this->__('Tab \'%s\' has been deleted.', $model->getTitle()));
180 |                 // go to grid
181 |                 $this->_redirect('*/*/');
182 |                 return;
183 |             } catch (Exception $e) {
184 |                 // display error message
185 |                 Mage::getSingleton('adminhtml/session')->addError($e->getMessage());
186 |                 // go back to edit form
187 |                 $this->_redirect('*/*/edit', array('id' => $id));
188 |                 return;
189 |             }
190 |         }
191 |         // display error message
192 |         Mage::getSingleton('adminhtml/session')->addError($this->__('Unable to find a tab to delete.'));
193 |         // go to grid
194 |         $this->_redirect('*/*/');
195 |     }
196 | 
197 |     public function loadTabOptionsAction()
198 |     {
199 |         try {
200 |             $this->loadLayout('empty');
201 |             if ($paramsJson = $this->getRequest()->getParam('widget')) {
202 |                 $request = Mage::helper('core')->jsonDecode($paramsJson);
203 |                 if (is_array($request)) {
204 |                     // $layout = $this->getLayout();
205 |                     // print_r((array_keys($layout->getAllBlocks())));die;
206 |                     $optionsBlock = $this->getLayout()->getBlock('easytabs.tab.options');
207 |                     if (isset($request['widget_type'])) {
208 |                         $optionsBlock->setWidgetType($request['widget_type']);
209 |                     }
210 |                     if (isset($request['values'])) {
211 |                         $optionsBlock->setWidgetValues($request['values']);
212 |                     }
213 |                 }
214 |                 $this->renderLayout();
215 |             }
216 |         } catch (Mage_Core_Exception $e) {
217 |             $result = array('error' => true, 'message' => $e->getMessage());
218 |             $this->getResponse()->setBody(Mage::helper('core')->jsonEncode($result));
219 |         }
220 |     }
221 | 
222 |     public function massDeleteAction()
223 |     {
224 |         $ids = $this->getRequest()->getParam('easytabs');
225 |         if (!is_array($ids)) {
226 |             Mage::getSingleton('adminhtml/session')
227 |                 ->addError(Mage::helper('adminhtml')->__('Please select item(s)'));
228 |         } else {
229 |             try {
230 |                 foreach ($ids as $id) {
231 |                     $model = Mage::getModel('easytabs/tab')->load($id);
232 |                     $model->delete();
233 |                 }
234 |                 Mage::getSingleton('adminhtml/session')->addSuccess(
235 |                     Mage::helper('adminhtml')->__(
236 |                         'Total of %d record(s) were successfully deleted', count($ids)
237 |                     )
238 |                 );
239 |             } catch (Exception $e) {
240 |                 Mage::getSingleton('adminhtml/session')->addError($e->getMessage());
241 |             }
242 |         }
243 |         $this->_redirect('*/*/index');
244 |     }
245 | 
246 |     public function massStatusAction()
247 |     {
248 |         $ids = $this->getRequest()->getParam('easytabs');
249 |         if (!is_array($ids)) {
250 |             Mage::getSingleton('adminhtml/session')
251 |                 ->addError(Mage::helper('adminhtml')->__('Please select item(s)'));
252 |         } else {
253 |             try {
254 |                 $status = $this->getRequest()->getParam('status');
255 |                 foreach ($ids as $id) {
256 |                     $model = Mage::getModel('easytabs/tab')->load($id);
257 |                     $model->setStatus($status)
258 |                         ->save();
259 |                 }
260 |                 Mage::getSingleton('adminhtml/session')->addSuccess(
261 |                     Mage::helper('adminhtml')->__(
262 |                         'Total of %d record(s) were successfully updated', count($ids)
263 |                     )
264 |                 );
265 |             } catch (Exception $e) {
266 |                 Mage::getSingleton('adminhtml/session')->addError($e->getMessage());
267 |             }
268 |         }
269 |         $this->_redirect('*/*/index');
270 |     }
271 | 
272 |     /**
273 |      * New Condition HTML
274 |      * @return [type] [description]
275 |      */
276 |     public function newConditionHtmlAction()
277 |     {
278 |         $id = $this->getRequest()->getParam('id');
279 |         $typeArr = explode('|', str_replace('-', '/', $this->getRequest()->getParam('type')));
280 |         $type = $typeArr[0];
281 |         $model = Mage::getModel($type)
282 |             ->setId($id)
283 |             ->setType($type)
284 |             ->setRule(Mage::getModel('easytabs/tab', array('product_tab' => $this->productTab)))
285 |             ->setPrefix('conditions');
286 |         if (!empty($typeArr[1])) {
287 |             $model->setAttribute($typeArr[1]);
288 |         }
289 |         if ($model instanceof Mage_Rule_Model_Condition_Abstract) {
290 |             $model->setJsFormObject($this->getRequest()->getParam('form'));
291 |             $html = $model->asHtmlRecursive();
292 |         } else {
293 |             $html = '';
294 |         }
295 |         $this->getResponse()->setBody($html);
296 |     }
297 | 
298 |     protected function _isAllowed()
299 |     {
300 |         $tabsType = $this->productTab ? 'product_tabs' : 'widget_tabs';
301 |         return Mage::getSingleton('admin/session')
302 |             ->isAllowed('templates_master/easytabs/' . $tabsType);
303 |     }
304 | 
305 | }
306 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Helper/Data.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class TM_EasyTabs_Helper_Data extends Mage_Core_Helper_Abstract
4 | {
5 |     
6 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Config/Layout.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Config_Layout extends Varien_Object
 4 | {
 5 |     const LAYOUT_COLLAPSED = 'collapsed';
 6 |     const LAYOUT_EXPANDED = 'expanded';
 7 | 
 8 | 
 9 |     public function toOptionArray()
10 |     {
11 |         $res = array();
12 |         foreach ($this->toOptionHash() as $value => $label) {
13 |             $res[] = array('value' => $value, 'label' => $label);
14 |         }
15 |         return $res;
16 |     }
17 | 
18 |     public function toOptionHash()
19 |     {
20 |         return array(
21 |             self::LAYOUT_COLLAPSED => Mage::helper('easytabs')->__('Collapsed tabs (traditional layout)'),
22 |             self::LAYOUT_EXPANDED => Mage::helper('easytabs')->__('Expanded tabs'),
23 |         );
24 |     }
25 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Config/Status.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Config_Status extends Varien_Object
 4 | {
 5 |     const STATUS_DISABLE = 0;
 6 |     const STATUS_ENABLE	 = 1;
 7 | 
 8 | 
 9 |     public function toOptionArray()
10 |     {
11 |         $res = array();
12 |         foreach ($this->toOptionHash() as $value => $label) {
13 |             $res[] = array('value' => $value, 'label' => $label);
14 |         }
15 |         return $res;
16 |     }
17 | 
18 |     public function toOptionHash()
19 |     {
20 |         return array(
21 |             self::STATUS_DISABLE => Mage::helper('easytabs')->__('Disable'),
22 |             self::STATUS_ENABLE  => Mage::helper('easytabs')->__('Enable'),
23 |         );
24 |     }
25 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Config/Tabs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Config_Tabs //extends Varien_Object
 4 | {
 5 |     const STATUS_DISABLE = 0;
 6 |     const STATUS_ENABLE  = 1;
 7 | 
 8 |     public function toOptionArray()
 9 |     {
10 |         $res = array();
11 |         foreach ($this->toOptionHash() as $value => $label) {
12 |             $res[] = array('value' => $value, 'label' => $label);
13 |         }
14 |         return $res;
15 |     }
16 | 
17 |     public function toOptionHash()
18 |     {
19 |         $collection = Mage::getModel('easytabs/tab')->getCollection()
20 |             ->addWidgetTabFilter();
21 | 
22 |         // \Zend_Debug::dump($collection->getFirstItem()->getData());
23 |         $res = array();
24 |         foreach ($collection as $tab) {
25 |             $res[$tab['alias']] = $tab['title'];
26 |         }
27 |         return $res;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Product/Attribute/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Product_Attribute_Collection extends Mage_Catalog_Model_Resource_Eav_Mysql4_Product_Attribute_Collection
 4 | {
 5 |     protected function _toOptionArray($valueField = 'attribute_code', $labelField = 'frontend_label', $additional = array())
 6 |     {
 7 |         $this->addVisibleFilter();
 8 |         return parent::_toOptionArray($valueField, $labelField, $additional);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Resource/Tab.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class TM_EasyTabs_Model_Resource_Tab
  4 |     extends Mage_Core_Model_Resource_Db_Abstract
  5 | {
  6 |     /**
  7 |      * Initialize resource model
  8 |      *
  9 |      */
 10 |     protected function _construct()
 11 |     {
 12 |         $this->_init('easytabs/tab', 'id');
 13 |     }
 14 | 
 15 |     protected function _beforeSave(Mage_Core_Model_Abstract $object)
 16 |     {
 17 | 
 18 |         if ($object->getBlockType() && !$object->getBlock()) {
 19 |             $object->setBlock($object->getBlockType());
 20 |         }
 21 | 
 22 |         return parent::_beforeSave($object);
 23 | 
 24 |     }
 25 | 
 26 | 
 27 |     /**
 28 |      * Process tab data before deleting
 29 |      *
 30 |      * @param Mage_Core_Model_Abstract $object
 31 |      * @return TM_EasyTabs_Model_Resource_Tab
 32 |      */
 33 |     protected function _beforeDelete(Mage_Core_Model_Abstract $object)
 34 |     {
 35 |         $condition = array(
 36 |             'tab_id = ?'     => (int) $object->getId(),
 37 |         );
 38 |         $this->_getWriteAdapter()->delete($this->getTable('easytabs/store'), $condition);
 39 |         return parent::_beforeDelete($object);
 40 |     }
 41 | 
 42 |     /**
 43 |      * Assign tab to store views
 44 |      *
 45 |      * @param Mage_Core_Model_Abstract $object
 46 |      * @return TM_EasyTabs_Model_Resource_Tab
 47 |      */
 48 |     protected function _afterSave(Mage_Core_Model_Abstract $object)
 49 |     {
 50 | 
 51 |         //  1. SAVE STORES FOR TAB
 52 |         $oldStores = $this->lookupStoreIds($object->getId());
 53 |         $newStores = (array)$object->getStores();
 54 |         if (empty($newStores)) {
 55 |             $newStores = (array)$object->getStoreId();
 56 |         }
 57 |         $table  = $this->getTable('easytabs/store');
 58 |         $insert = array_diff($newStores, $oldStores);
 59 |         $delete = array_diff($oldStores, $newStores);
 60 |         if ($delete) {
 61 |             $where = array(
 62 |                 'tab_id = ?'     => (int) $object->getId(),
 63 |                 'store_id IN (?)' => $delete
 64 |             );
 65 |             $this->_getWriteAdapter()->delete($table, $where);
 66 |         }
 67 |         if ($insert) {
 68 |             $data = array();
 69 |             foreach ($insert as $storeId) {
 70 |                 try {
 71 |                     $store = Mage::app()->getStore($storeId);
 72 |                     $data[] = array(
 73 |                         'tab_id'  => (int) $object->getId(),
 74 |                         'store_id' => (int) $store->getId()
 75 |                     );
 76 |                 }
 77 |                 catch (Exception $e) {
 78 |                     // ignore id if there are no such store
 79 |                 }
 80 |             }
 81 |             if (!empty($data)) {
 82 |                 $this->_getWriteAdapter()->insertMultiple($table, $data);
 83 |             }
 84 |         }
 85 | 
 86 |         //Mark layout cache as invalidated
 87 |         Mage::app()->getCacheInstance()->invalidateType('layout');
 88 | 
 89 |         return parent::_afterSave($object);
 90 | 
 91 |     }
 92 | 
 93 |     /**
 94 |      * Perform operations after object load
 95 |      *
 96 |      * @param Mage_Core_Model_Abstract $object
 97 |      * @return TM_EasyTabs_Model_Resource_Tab
 98 |      */
 99 |     protected function _afterLoad(Mage_Core_Model_Abstract $object)
100 |     {
101 |         if ($object->getId()) {
102 |             // get stores assigned to deal
103 |             $stores = $this->lookupStoreIds($object->getId());
104 |             $object->setData('store_id', $stores);
105 |         }
106 |         return parent::_afterLoad($object);
107 |     }
108 | 
109 |     /**
110 |      * Get store ids to which specified item is assigned
111 |      *
112 |      * @param int $id
113 |      * @return array
114 |      */
115 |     public function lookupStoreIds($tabId)
116 |     {
117 |         $adapter = $this->_getReadAdapter();
118 |         $select  = $adapter->select()
119 |             ->from($this->getTable('easytabs/store'), 'store_id')
120 |             ->where('tab_id = ?', (int)$tabId);
121 |         return $adapter->fetchCol($select);
122 |     }
123 | 
124 | }
125 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Resource/Tab/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Resource_Tab_Collection
 4 |     extends Mage_Core_Model_Resource_Db_Collection_Abstract
 5 | {
 6 |     /**
 7 |      * Define resource model
 8 |      *
 9 |      */
10 |     protected function _construct()
11 |     {
12 |         $this->_init('easytabs/tab');
13 |         $this->_map['fields']['id'] = 'main_table.id';
14 |         $this->_map['fields']['store'] = 'store_table.store_id';
15 |     }
16 | 
17 |     /**
18 |      * Add filter by store
19 |      *
20 |      * @param int|Mage_Core_Model_Store $store
21 |      * @param bool $withAdmin
22 |      * @return TM_EasyTabs_Model_Resource_Tab_Collection
23 |      */
24 |     public function addStoreFilter($store, $withAdmin = true)
25 |     {
26 |         if (!$this->getFlag('store_filter_added')) {
27 |             if ($store instanceof Mage_Core_Model_Store) {
28 |                 $store = array($store->getId());
29 |             }
30 |             if (!is_array($store)) {
31 |                 $store = array($store);
32 |             }
33 |             if ($withAdmin) {
34 |                 $store[] = Mage_Core_Model_App::ADMIN_STORE_ID;
35 |             }
36 |             $this->addFilter('store', array('in' => $store), 'public');
37 |         }
38 |         return $this;
39 |     }
40 | 
41 |     /**
42 |      * Join store relation table if there is store filter
43 |      */
44 |     protected function _renderFiltersBefore()
45 |     {
46 |         if ($this->getFilter('store')) {
47 |             $this->getSelect()->join(
48 |                 array('store_table' => $this->getTable('easytabs/store')),
49 |                 'main_table.id = store_table.tab_id',
50 |                 array()
51 |             )->group('main_table.id');
52 |             /*
53 |              * Allow analytic functions usage because of one field grouping
54 |              */
55 |             $this->_useAnalyticFunction = true;
56 |         }
57 |         return parent::_renderFiltersBefore();
58 |     }
59 | 
60 | 
61 |     /**
62 |      * Get SQL for get record count.
63 |      * Extra GROUP BY strip added.
64 |      *
65 |      * @return Varien_Db_Select
66 |      */
67 |     public function getSelectCountSql()
68 |     {
69 |         $countSelect = parent::getSelectCountSql();
70 |         $countSelect->reset(Zend_Db_Select::GROUP);
71 |         return $countSelect;
72 |     }
73 | 
74 |     public function addProductTabFilter()
75 |     {
76 |         return $this->addFieldToFilter('product_tab', array('eq' => '1'));
77 |     }
78 | 
79 |     public function addWidgetTabFilter()
80 |     {
81 |         return $this->addFieldToFilter('product_tab', array('eq' => '0'));
82 |     }
83 | 
84 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Rule/Condition/Combine.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Rule_Condition_Combine
 4 |     extends Mage_CatalogRule_Model_Rule_Condition_Combine
 5 | 
 6 | {
 7 |     public function __construct()
 8 |     {
 9 |         parent::__construct();
10 |         $this->setType('easytabs/rule_condition_combine');
11 |     }
12 | 
13 |     public function getNewChildSelectOptions()
14 |     {
15 |         $conditions = parent::getNewChildSelectOptions();
16 |         if (isset($conditions[1]['value'])
17 |             && $conditions[1]['value'] == 'catalogrule/rule_condition_combine'
18 |         ) {
19 |             $conditions[1]['value'] = $this->getType();
20 |         }
21 | 
22 |         $customerConditions = array(
23 |             array(
24 |                 'label' => Mage::helper('customer')->__('Customers'),
25 |                 'value' => array(
26 |                     array(
27 |                         'label' => Mage::helper('customer')->__('Customer Groups'),
28 |                         'value' => 'easytabs/rule_condition_customer|customer_group'
29 |                     )
30 |                 )
31 |             )
32 |         );
33 | 
34 |         // very bold assumption that $conditions[2] is product attributes
35 |         if (isset($conditions[2]) && !$this->getRule()->getProductTab()) {
36 |             unset($conditions[2]);
37 |         }
38 |         array_splice($conditions, 2, 0, $customerConditions);
39 | 
40 |         return $conditions;
41 |     }
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Rule/Condition/Customer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Rule_Condition_Customer
 4 |     extends Mage_Rule_Model_Condition_Abstract
 5 | 
 6 | {
 7 | 
 8 |     public function loadAttributeOptions()
 9 |     {
10 |         $options = array(
11 |             'customer_group' => Mage::helper('customer')->__('Customer Groups')
12 |         );
13 |         $this->setAttributeOption($options);
14 |         return $this;
15 |     }
16 | 
17 |     /**
18 |      * Retrieve value element type
19 |      *
20 |      * @return string
21 |      */
22 |     public function getValueElementType()
23 |     {
24 |         if ($this->getAttribute() == 'customer_group') {
25 |             return 'select';
26 |         }
27 |         return parent::getValueElementType();
28 |     }
29 | 
30 |     /**
31 |      * Retrieve select option values
32 |      *
33 |      * @return array
34 |      */
35 |     public function getValueSelectOptions()
36 |     {
37 |         $options = array();
38 |         $collection = Mage::getModel('customer/group')->getCollection();
39 |         foreach ($collection as $group) {
40 |             $options[] = array(
41 |                 'label' => $group->getCustomerGroupCode(),
42 |                 'value' => $group->getId(),
43 |             );
44 |         }
45 |         return $options;
46 |     }
47 | 
48 |     /**
49 |      * Retrieve input type
50 |      *
51 |      * @return string
52 |      */
53 |     public function getInputType()
54 |     {
55 |         if ($this->getAttribute() == 'customer_group') {
56 |             return 'select';
57 |         }
58 |         return parent::getInputType();
59 |     }
60 | 
61 | }
62 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Tab.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Tab extends Mage_Rule_Model_Abstract
 4 | {
 5 | 
 6 |     const CACHE_TAG = 'easytabs_tab_';
 7 |     protected $_cacheTag = self::CACHE_TAG;
 8 | 
 9 |     /**
10 |      * Initialize resource model
11 |      */
12 |     protected function _construct()
13 |     {
14 |         $this->_init('easytabs/tab');
15 |     }
16 | 
17 |     /**
18 |      * Getter for rule actions collection instance
19 |      *
20 |      * @return Mage_Rule_Model_Action_Collection
21 |      */
22 |     public function getActionsInstance()
23 |     {
24 |         return Mage::getModel('rule/action_collection');
25 |     }
26 | 
27 |     public function getConditionsInstance()
28 |     {
29 |         return Mage::getModel('easytabs/rule_condition_combine');
30 |     }
31 | 
32 | }
33 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Tabs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Tabs extends Mage_Widget_Model_Widget
 4 | {
 5 |     /**
 6 |      * Load Easytabs XML config from easytabs.xml files and cache it
 7 |      *
 8 |      * @return Varien_Simplexml_Config
 9 |      */
10 |     public function getXmlConfig()
11 |     {
12 |         $cachedXml = Mage::app()->loadCache('easytabs_config');
13 |         if ($cachedXml) {
14 |             $xmlConfig = new Varien_Simplexml_Config($cachedXml);
15 |         } else {
16 |             $config = new Varien_Simplexml_Config();
17 |             $config->loadString('<?xml version="1.0"?><easytabs></easytabs>');
18 |             Mage::getConfig()->loadModulesConfiguration('easytabs.xml', $config);
19 |             $xmlConfig = $config;
20 |             if (Mage::app()->useCache('config')) {
21 |                 Mage::app()->saveCache($config->getXmlString(), 'easytabs_config',
22 |                     array(Mage_Core_Model_Config::CACHE_TAG));
23 |             }
24 |         }
25 |         return $xmlConfig;
26 |     }
27 | 
28 |     public function getTabsArray($filters = array())
29 |     {
30 |         return parent::getWidgetsArray($filters);
31 |     }
32 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/Model/Template/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Model_Template_Filter extends Mage_Widget_Model_Template_Filter
 4 | {
 5 |     protected $_scope;
 6 | 
 7 |     public function setScope($scope)
 8 |     {
 9 |         $this->_scope = $scope;
10 |         return $this;
11 |     }
12 | 
13 |     public function getScope()
14 |     {
15 |         return $this->_scope;
16 |     }
17 | 
18 |     public function evalDirective($construction)
19 |     {
20 |         $params = $this->_getIncludeParameters($construction[2]);
21 | 
22 |         if (isset($params['scope'])) {
23 |             $scope = $params['scope'];
24 |             $scope = Mage::app()->getLayout()->getBlock($scope);
25 |             $this->setScope($scope);
26 |         }
27 | 
28 |         $scope = $this->getScope();
29 |         if (!$scope || !isset($params['code'])) {
30 |             return '';
31 |         }
32 | 
33 |         $methods = explode('->', str_replace(array('(', ')'), '', $params['code']));
34 | 
35 |         foreach ($methods as $method) {
36 |             $callback = array($scope, $method);
37 |             if(!is_callable($callback)) {
38 |                 continue;
39 |             }
40 |             
41 |             try {
42 |                 $replacedValue = call_user_func($callback);
43 |             } catch (Exception $e) {
44 |                 throw $e;
45 |             }
46 |             
47 |             $scope = $replacedValue;
48 |         }
49 | 
50 |         return (string) $replacedValue;
51 |     }
52 | }


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/controllers/Adminhtml/Easytabs/ProductController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Adminhtml_Easytabs_ProductController
 4 |     extends TM_EasyTabs_Controller_Adminhtml_Abstract
 5 | {
 6 | 
 7 |     public function _construct()
 8 |     {
 9 |         // set flag `product tab`
10 |         $this->productTab = 1;
11 |         parent::_construct();
12 |     }
13 | 
14 |     public function indexAction()
15 |     {
16 |         $this->_title($this->__('TM'))
17 |             ->_title($this->__('Easy Tabs'))
18 |             ->_title($this->__('Product Tabs'));
19 |         parent::indexAction();
20 |     }
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/controllers/Adminhtml/Easytabs/WidgetController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TM_EasyTabs_Adminhtml_Easytabs_WidgetController
 4 |     extends TM_EasyTabs_Controller_Adminhtml_Abstract
 5 | {
 6 | 
 7 |     public function indexAction()
 8 |     {
 9 |         $this->_title($this->__('TM'))
10 |             ->_title($this->__('Easy Tabs'))
11 |             ->_title($this->__('Widget Tabs'));
12 |         parent::indexAction();
13 |     }
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/data/easytabs_setup/data-upgrade-2.3.8-2.4.0.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 |     $str = <<<TABDATA
  4 | {
  5 |     "1":{
  6 |       "title":"Product Description",
  7 |       "alias":"description_tabbed",
  8 |       "block":"easytabs\/tab_product_description",
  9 |       "custom_option":null,
 10 |       "template":"tm\/easytabs\/tab\/catalog\/product\/view\/description.phtml",
 11 |       "unset":"product.info::description",
 12 |       "sort_order":1,
 13 |       "status":true,
 14 |       "store_id":"0"
 15 |     },
 16 |     "2":{
 17 |       "title":"Additional Information",
 18 |       "alias":"additional_tabbed",
 19 |       "block":"easytabs\/tab_product_additional",
 20 |       "custom_option":null,
 21 |       "template":"tm\/easytabs\/tab\/catalog\/product\/view\/attributes.phtml",
 22 |       "unset":"product.info::additional",
 23 |       "sort_order":2,
 24 |       "status":true,
 25 |       "store_id":"0"
 26 |     },
 27 |     "3":{
 28 |       "title":"We Also Recommend",
 29 |       "alias":"upsell_products_tabbed",
 30 |       "block":"easytabs\/tab_product_upsell",
 31 |       "custom_option":null,
 32 |       "template":"catalog\/product\/list\/upsell.phtml",
 33 |       "unset":"product.info::upsell_products",
 34 |       "sort_order":4,
 35 |       "status":true,
 36 |       "store_id":"0"
 37 |     },
 38 |     "4":{
 39 |       "title":"Related Products",
 40 |       "alias":"related_tabbed",
 41 |       "block":"easytabs\/tab_product_related",
 42 |       "custom_option":null,
 43 |       "template":"tm\/easytabs\/tab\/catalog\/product\/related.phtml",
 44 |       "unset":"right::catalog.product.related,product.info::related_products",
 45 |       "sort_order":5,
 46 |       "status":true,
 47 |       "store_id":"0"
 48 |     },
 49 |     "5":{
 50 |       "title":"Tags&nbsp;({{eval code=\"getCount()\"}})",
 51 |       "alias":"tags_tabbed",
 52 |       "block":"easytabs\/tab_product_tags",
 53 |       "custom_option":null,
 54 |       "template":"tm\/easytabs\/tab\/tag\/product\/list.phtml",
 55 |       "unset":"product.info.additional::product_tag_list",
 56 |       "sort_order":6,
 57 |       "status":true,
 58 |       "store_id": "0"
 59 |     },
 60 |     "6":{
 61 |       "title":"Reviews&nbsp;({{eval code=\"getReviewsCollection()->count()\"}})",
 62 |       "alias":"review_tabbed",
 63 |       "block":"easytabs\/tab_product_review",
 64 |       "custom_option":null,
 65 |       "template":"tm\/easytabs\/tab\/review\/product\/view\/list.phtml",
 66 |       "unset":"product.info::reviews",
 67 |       "sort_order":7,
 68 |       "status":true,
 69 |       "store_id": "0"
 70 |     },
 71 |     "7":{
 72 |       "title":"electronics-landing",
 73 |       "alias":"cms",
 74 |       "block":"easytabs\/tab_cms",
 75 |       "custom_option":"electronics-landing",
 76 |       "template":"tm\/easytabs\/tab\/cms.phtml",
 77 |       "unset":"",
 78 |       "sort_order":8,
 79 |       "status":false,
 80 |       "store_id":"0"
 81 |     },
 82 |     "8":{
 83 |       "title":"Color Attribute",
 84 |       "alias":"attribute",
 85 |       "block":"easytabs\/tab_attribute",
 86 |       "custom_option":"color",
 87 |       "template":"tm\/easytabs\/tab\/catalog\/product\/attribute.phtml",
 88 |       "unset":"",
 89 |       "sort_order":9,
 90 |       "status":false,
 91 |       "store_id":"0"
 92 |     },
 93 |     "9":{
 94 |       "title":"Recurring Profile",
 95 |       "alias":"recurring_info",
 96 |       "block":"easytabs\/tab_template",
 97 |       "custom_option":"payment\/catalog_product_view_profile",
 98 |       "template":"payment\/catalog\/product\/view\/profile\/schedule.phtml",
 99 |       "unset":"product.info::recurring_info",
100 |       "sort_order":10,
101 |       "status":true,
102 |       "store_id":"0"
103 |     }
104 | }
105 | TABDATA;
106 | 
107 |     if (Mage::getStoreConfig('tm_easytabs/general/config')) {
108 |         $str = Mage::getStoreConfig('tm_easytabs/general/config');
109 |     }
110 | 
111 |     $tabsData = json_decode($str, true);
112 | 
113 |     foreach ($tabsData as $data) {
114 |         $tab = Mage::getModel('easytabs/tab');
115 |         $tab->setData($data);
116 |         $tab->setProductTab(1);
117 |         $tab->unsetData('id');
118 |         $tab->save();
119 |     }
120 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/data/easytabs_setup/data-upgrade-3.0.0-3.0.1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 |     // use Custom Block instead of Tab Product Related
 4 |     $tabsRelated = Mage::getModel('easytabs/tab')->getCollection()
 5 |         ->addProductTabFilter()
 6 |         ->addFilter('block', array('eq' => 'easytabs/tab_product_related'));
 7 | 
 8 |     foreach ($tabsRelated as $tab) {
 9 |         $tab->afterLoad();
10 |         $tab->setBlock('easytabs/tab_template');
11 |         $tab->setCustomOption('catalog/product_list_related');
12 |         $tab->setTemplate('catalog/product/list/related.phtml');
13 |         $tab->save();
14 |     }
15 | 
16 |     // use Custom Block instead of Tab Product Upsell
17 |     $tabsRelated = Mage::getModel('easytabs/tab')->getCollection()
18 |         ->addProductTabFilter()
19 |         ->addFilter('block', array('eq' => 'easytabs/tab_product_upsell'));
20 | 
21 |     foreach ($tabsRelated as $tab) {
22 |         $tab->afterLoad();
23 |         $tab->setBlock('easytabs/tab_template');
24 |         $tab->setCustomOption('catalog/product_list_upsell');
25 |         $tab->save();
26 |     }
27 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/etc/adminhtml.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <config>
 3 |     <menu>
 4 |         <templates_master>
 5 |             <title>Templates Master</title>
 6 |             <sort_order>71</sort_order>
 7 |             <children>
 8 |                 <easytabs translate="title" module="easytabs">
 9 |                     <title>Easy Tabs</title>
10 |                     <sort_order>540</sort_order>
11 |                     <children>
12 |                         <product_tabs translate="title" module="easytabs">
13 |                             <title>Product Tabs</title>
14 |                             <sort_order>10</sort_order>
15 |                             <action>adminhtml/easytabs_product</action>
16 |                         </product_tabs>
17 |                         <widget_tabs translate="title" module="easytabs">
18 |                             <title>Widget Tabs</title>
19 |                             <sort_order>20</sort_order>
20 |                             <action>adminhtml/easytabs_widget</action>
21 |                         </widget_tabs>
22 |                     </children>
23 |                 </easytabs>
24 |             </children>
25 |         </templates_master>
26 |     </menu>
27 | 
28 |     <acl>
29 |         <resources>
30 |             <admin>
31 |                 <children>
32 |                     <system>
33 |                         <children>
34 |                             <config>
35 |                                 <children>
36 |                                     <tm_easytabs translate="title" module="easytabs">
37 |                                         <title>Easy Tabs Section</title>
38 |                                     </tm_easytabs>
39 |                                 </children>
40 |                             </config>
41 |                         </children>
42 |                     </system>
43 |                     <templates_master>
44 |                         <children>
45 |                             <easytabs module="easytabs">
46 |                                 <title>Easy Tabs</title>
47 |                                 <sort_order>540</sort_order>
48 |                                 <children>
49 |                                     <product_tabs translate="title" module="easytabs">
50 |                                         <title>Product Tabs</title>
51 |                                         <sort_order>10</sort_order>
52 |                                     </product_tabs>
53 |                                     <widget_tabs translate="title" module="easytabs">
54 |                                         <title>Widget Tabs</title>
55 |                                         <sort_order>20</sort_order>
56 |                                     </widget_tabs>
57 |                                 </children>
58 |                             </easytabs>
59 |                         </children>
60 |                     </templates_master>
61 |                 </children>
62 |             </admin>
63 |         </resources>
64 |     </acl>
65 |  </config>
66 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/etc/config.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <config>
  3 |     <modules>
  4 |         <TM_EasyTabs>
  5 |             <version>3.2.4</version>
  6 |         </TM_EasyTabs>
  7 |     </modules>
  8 | 
  9 |     <global>
 10 |         <helpers>
 11 |             <easytabs>
 12 |                 <class>TM_EasyTabs_Helper</class>
 13 |             </easytabs>
 14 |         </helpers>
 15 |         <blocks>
 16 |             <easytabs>
 17 |                 <class>TM_EasyTabs_Block</class>
 18 |             </easytabs>
 19 |         </blocks>
 20 | 
 21 |         <resources>
 22 |             <easytabs_setup>
 23 |                 <setup>
 24 |                     <module>TM_EasyTabs</module>
 25 |                 </setup>
 26 |             </easytabs_setup>
 27 |         </resources>
 28 |         <models>
 29 |             <easytabs>
 30 |                 <class>TM_EasyTabs_Model</class>
 31 |                 <resourceModel>easytabs_resource</resourceModel>
 32 |             </easytabs>
 33 |             <easytabs_resource>
 34 |                 <class>TM_EasyTabs_Model_Resource</class>
 35 |                 <entities>
 36 |                     <tab>
 37 |                         <table>tm_easytab</table>
 38 |                     </tab>
 39 |                     <store>
 40 |                         <table>tm_easytab_store</table>
 41 |                     </store>
 42 |                 </entities>
 43 |             </easytabs_resource>
 44 |         </models>
 45 |     </global>
 46 | 
 47 |     <frontend>
 48 |         <layout>
 49 |             <updates>
 50 |                 <easytabs>
 51 |                     <file>tm/easytabs.xml</file>
 52 |                 </easytabs>
 53 |             </updates>
 54 |         </layout>
 55 |         <translate>
 56 |             <modules>
 57 |                 <TM_EasyTabs>
 58 |                     <files>
 59 |                         <default>TM_EasyTabs.csv</default>
 60 |                     </files>
 61 |                 </TM_EasyTabs>
 62 |             </modules>
 63 |         </translate>
 64 |     </frontend>
 65 | 
 66 |     <default>
 67 |         <subscriptionchecker>
 68 |             <ignored_sections>
 69 |                 <tm_easytabs/>
 70 |             </ignored_sections>
 71 |         </subscriptionchecker>
 72 |         <tm_easytabs>
 73 |             <general>
 74 |                 <enabled>0</enabled>
 75 |                 <tabs_layout>collapsed</tabs_layout>
 76 |                 <update_url_hash>1</update_url_hash>
 77 |                 <show_anchor>0</show_anchor>
 78 |             </general>
 79 |         </tm_easytabs>
 80 |     </default>
 81 | 
 82 |     <admin>
 83 |         <routers>
 84 |             <adminhtml>
 85 |                 <args>
 86 |                     <modules>
 87 |                         <easytabs before="Mage_Adminhtml">TM_EasyTabs_Adminhtml</easytabs>
 88 |                     </modules>
 89 |                 </args>
 90 |             </adminhtml>
 91 |         </routers>
 92 |     </admin>
 93 | 
 94 |     <adminhtml>
 95 |         <layout>
 96 |             <updates>
 97 |                 <easytabs>
 98 |                     <file>tm/easytabs.xml</file>
 99 |                 </easytabs>
100 |             </updates>
101 |         </layout>
102 | 
103 |         <translate>
104 |             <modules>
105 |                 <TM_EasyTabs>
106 |                     <files>
107 |                         <default>TM_EasyTabs.csv</default>
108 |                     </files>
109 |                 </TM_EasyTabs>
110 |             </modules>
111 |         </translate>
112 |     </adminhtml>
113 | </config>
114 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/etc/easytabs.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <easytabs>
  3 |     <html type="easytabs/tab_html">
  4 |         <name>Html content</name>
  5 |         <parameters>
  6 |             <content>
  7 |                 <label>Content</label>
  8 |                 <type>tmcore/adminhtml_widget_form_renderer_wysiwyg</type>
  9 |                 <visible>1</visible>
 10 |                 <required>1</required>
 11 |                 <value></value>
 12 |             </content>
 13 |             <unset>
 14 |                 <label>Unset(reference::block_alias)</label>
 15 |                 <type>text</type>
 16 |                 <visible>1</visible>
 17 |                 <required>0</required>
 18 |                 <value></value>
 19 |             </unset>
 20 |         </parameters>
 21 |     </html>
 22 |     <template type="easytabs/tab_template">
 23 |         <name>Custom Block</name>
 24 |         <parameters>
 25 |             <custom_option>
 26 |                 <label>Block</label>
 27 |                 <type>text</type>
 28 |                 <visible>1</visible>
 29 |                 <required>1</required>
 30 |                 <value></value>
 31 |             </custom_option>
 32 |             <template>
 33 |                 <label>Template</label>
 34 |                 <type>text</type>
 35 |                 <visible>1</visible>
 36 |                 <required>1</required>
 37 |                 <value></value>
 38 |             </template>
 39 |             <unset>
 40 |                 <label>Unset(reference::block_alias)</label>
 41 |                 <type>text</type>
 42 |                 <visible>1</visible>
 43 |                 <required>0</required>
 44 |                 <value></value>
 45 |             </unset>
 46 |         </parameters>
 47 |     </template>
 48 |     <attribute type="easytabs/tab_attribute">
 49 |         <name>Product attribute</name>
 50 |         <parameters>
 51 |             <custom_option>
 52 |                 <label>Attribute Code</label>
 53 |                 <type>select</type>
 54 |                 <visible>1</visible>
 55 |                 <required>1</required>
 56 |                 <value></value>
 57 |                 <source_model>easytabs/product_attribute_collection</source_model>
 58 |             </custom_option>
 59 |             <template>
 60 |                 <label>Template</label>
 61 |                 <type>text</type>
 62 |                 <visible>1</visible>
 63 |                 <required>1</required>
 64 |                 <value>tm/easytabs/tab/catalog/product/attribute.phtml</value>
 65 |             </template>
 66 |         </parameters>
 67 |     </attribute>
 68 |     <product_description type="easytabs/tab_product_description">
 69 |         <name>Product Desription</name>
 70 |         <parameters>
 71 |             <template>
 72 |                 <label>Template</label>
 73 |                 <type>text</type>
 74 |                 <visible>1</visible>
 75 |                 <required>1</required>
 76 |                 <value>tm/easytabs/tab/catalog/product/view/description.phtml</value>
 77 |             </template>
 78 |             <unset>
 79 |                 <label>Unset</label>
 80 |                 <type>text</type>
 81 |                 <visible>1</visible>
 82 |                 <required>0</required>
 83 |                 <value>product.info::description</value>
 84 |             </unset>
 85 |         </parameters>
 86 |     </product_description>
 87 |     <product_additional type="easytabs/tab_product_additional">
 88 |         <name>Additional Information</name>
 89 |         <parameters>
 90 |             <template>
 91 |                 <label>Template</label>
 92 |                 <type>text</type>
 93 |                 <visible>1</visible>
 94 |                 <required>1</required>
 95 |                 <value>tm/easytabs/tab/catalog/product/view/attributes.phtml</value>
 96 |             </template>
 97 |             <unset>
 98 |                 <label>Unset</label>
 99 |                 <type>text</type>
100 |                 <visible>1</visible>
101 |                 <required>0</required>
102 |                 <value>product.info::additional</value>
103 |             </unset>
104 |         </parameters>
105 |     </product_additional>
106 |     <product_tags type="easytabs/tab_product_tags">
107 |         <name>Product Tags ({{eval code="getCount()"}})</name>
108 |         <parameters>
109 |             <template>
110 |                 <label>Template</label>
111 |                 <type>text</type>
112 |                 <visible>1</visible>
113 |                 <required>1</required>
114 |                 <value>tm/easytabs/tab/tag/product/list.phtml</value>
115 |             </template>
116 |             <unset>
117 |                 <label>Unset</label>
118 |                 <type>text</type>
119 |                 <visible>1</visible>
120 |                 <required>0</required>
121 |                 <value>product.info.additional::product_tag_list</value>
122 |             </unset>
123 |         </parameters>
124 |     </product_tags>
125 |     <product_review type="easytabs/tab_product_review">
126 |         <name>Product's Reviews ({{eval  code="getReviewsCollection()->count()"}})</name>
127 |         <parameters>
128 |             <template>
129 |                 <label>Template</label>
130 |                 <type>text</type>
131 |                 <visible>1</visible>
132 |                 <required>1</required>
133 |                 <value>tm/easytabs/tab/review/product/view/list.phtml</value>
134 |                 <!-- <value>review/product/view/list.phtml</value> -->
135 |             </template>
136 |             <unset>
137 |                 <label>Unset</label>
138 |                 <type>text</type>
139 |                 <visible>1</visible>
140 |                 <required>0</required>
141 |                 <value>product.info::reviews</value>
142 |             </unset>
143 |         </parameters>
144 |     </product_review>
145 |     <cms type="easytabs/tab_cms">
146 |         <name>CMS Static Block</name>
147 |         <parameters>
148 |             <custom_option>
149 |                 <label>Identifier</label>
150 |                 <type>select</type>
151 |                 <visible>1</visible>
152 |                 <required>1</required>
153 |                 <value></value>
154 |                 <source_model>cms/mysql4_block_collection</source_model>
155 |             </custom_option>
156 |             <template>
157 |                 <label>Template</label>
158 |                 <type>text</type>
159 |                 <visible>1</visible>
160 |                 <required>1</required>
161 |                 <value>tm/easytabs/tab/cms.phtml</value>
162 |             </template>
163 |         </parameters>
164 |     </cms>
165 | </easytabs>
166 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/etc/system.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <config>
 3 |     <tabs>
 4 |         <templates_master translate="label" module="easytabs">
 5 |             <label>Templates-master</label>
 6 |             <sort_order>196</sort_order>
 7 |         </templates_master>
 8 |     </tabs>
 9 |     <sections>
10 |         <tm_easytabs translate="label" module="easytabs">
11 |             <label>Easy Tabs</label>
12 |             <tab>templates_master</tab>
13 |             <frontend_type>text</frontend_type>
14 |             <sort_order>540</sort_order>
15 |             <show_in_default>1</show_in_default>
16 |             <show_in_website>1</show_in_website>
17 |             <show_in_store>1</show_in_store>
18 |             <groups>
19 |                 <general translate="label">
20 |                     <label>General</label>
21 |                     <frontend_type>text</frontend_type>
22 |                     <sort_order>10</sort_order>
23 |                     <show_in_default>1</show_in_default>
24 |                     <show_in_website>1</show_in_website>
25 |                     <show_in_store>1</show_in_store>
26 |                     <fields>
27 |                         <enabled translate="label">
28 |                             <label>Enabled</label>
29 |                             <frontend_type>select</frontend_type>
30 |                             <source_model>adminhtml/system_config_source_yesno</source_model>
31 |                             <sort_order>10</sort_order>
32 |                             <show_in_default>1</show_in_default>
33 |                             <show_in_website>1</show_in_website>
34 |                             <show_in_store>1</show_in_store>
35 |                         </enabled>
36 |                         <heading_blocks translate="label">
37 |                             <label>Product Page tabs</label>
38 |                             <frontend_model>adminhtml/system_config_form_field_heading</frontend_model>
39 |                             <sort_order>12</sort_order>
40 |                             <show_in_default>1</show_in_default>
41 |                             <show_in_website>1</show_in_website>
42 |                             <show_in_store>1</show_in_store>
43 |                         </heading_blocks>
44 |                         <tabs_layout translate="label">
45 |                             <label>Layout</label>
46 |                             <frontend_type>select</frontend_type>
47 |                             <source_model>easytabs/config_layout</source_model>
48 |                             <sort_order>14</sort_order>
49 |                             <show_in_default>1</show_in_default>
50 |                             <show_in_website>1</show_in_website>
51 |                             <show_in_store>1</show_in_store>
52 |                         </tabs_layout>
53 |                         <sticky_tabs translate="label">
54 |                             <label>Stick tabs header on scroll</label>
55 |                             <frontend_type>select</frontend_type>
56 |                             <source_model>adminhtml/system_config_source_yesno</source_model>
57 |                             <sort_order>14</sort_order>
58 |                             <show_in_default>1</show_in_default>
59 |                             <show_in_website>1</show_in_website>
60 |                             <show_in_store>1</show_in_store>
61 |                         </sticky_tabs>
62 |                         <group_attributes translate="label">
63 |                             <label>Group attributes on "Additional Information" tab</label>
64 |                             <frontend_type>select</frontend_type>
65 |                             <source_model>adminhtml/system_config_source_yesno</source_model>
66 |                             <sort_order>16</sort_order>
67 |                             <show_in_default>1</show_in_default>
68 |                             <show_in_website>1</show_in_website>
69 |                             <show_in_store>1</show_in_store>
70 |                         </group_attributes>
71 |                         <update_url_hash translate="label">
72 |                             <label>Update url when switch between tabs</label>
73 |                             <frontend_type>select</frontend_type>
74 |                             <source_model>adminhtml/system_config_source_yesno</source_model>
75 |                             <sort_order>20</sort_order>
76 |                             <show_in_default>1</show_in_default>
77 |                             <show_in_website>1</show_in_website>
78 |                             <show_in_store>1</show_in_store>
79 |                         </update_url_hash>
80 |                         <show_anchor translate="label">
81 |                             <label>Show tab anchor when hovering tab</label>
82 |                             <frontend_type>select</frontend_type>
83 |                             <source_model>adminhtml/system_config_source_yesno</source_model>
84 |                             <depends>
85 |                                 <update_url_hash>0</update_url_hash>
86 |                             </depends>
87 |                             <sort_order>30</sort_order>
88 |                             <show_in_default>1</show_in_default>
89 |                             <show_in_website>1</show_in_website>
90 |                             <show_in_store>1</show_in_store>
91 |                         </show_anchor>
92 |                     </fields>
93 |                 </general>
94 |             </groups>
95 |         </tm_easytabs>
96 |     </sections>
97 | </config>
98 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/etc/tmamp.xml:
--------------------------------------------------------------------------------
 1 | <config>
 2 |     <tmamp>
 3 |         <whitelist>
 4 |             <layout_updates>
 5 |                 <tm_easytabs>
 6 |                     <xml>tm/easytabs.xml</xml>
 7 |                 </tm_easytabs>
 8 |             </layout_updates>
 9 |             <block_types>
10 |                 <tm_easytabs>
11 |                     <product>easytabs/product</product>
12 |                     <product_description>easytabs/tab_product_description</product_description>
13 |                     <product_additional>easytabs/tab_product_additional</product_additional>
14 |                     <template>easytabs/tab_template</template>
15 |                     <html>easytabs/tab_html</html>
16 |                 </tm_easytabs>
17 |             </block_types>
18 |         </whitelist>
19 |     </tmamp>
20 | </config>
21 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/etc/widget.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <widgets>
 3 |     <easytabs type="easytabs/widget">
 4 |         <name>Easy Tabs</name>
 5 |         <parameters>
 6 |             <filter_tabs>
 7 |                 <visible>1</visible>
 8 |                 <required>1</required>
 9 |                 <label>Tabs to show</label>
10 |                 <description><![CDATA[List of tabs from "Templates Master" &rarr; "Easytabs" &rarr; "Widget Tabs"]]></description>
11 |                 <type>multiselect</type>
12 |                 <source_model>easytabs/config_tabs</source_model>
13 |                 <helper_block>
14 |                     <type>easytabs/adminhtml_widget_chosen</type>
15 |                 </helper_block>
16 |             </filter_tabs>
17 |             <tabs_layout>
18 |                 <visible>1</visible>
19 |                 <label>Layout</label>
20 |                 <type>select</type>
21 |                 <source_model>easytabs/config_layout</source_model>
22 |             </tabs_layout>
23 |             <sticky_tabs>
24 |                 <visible>1</visible>
25 |                 <label>Stick tabs header on scroll</label>
26 |                 <type>select</type>
27 |                 <source_model>adminhtml/system_config_source_yesno</source_model>
28 |             </sticky_tabs>
29 |             <template>
30 |                 <type>hidden</type>
31 |                 <value>tm/easytabs/tabs.phtml</value>
32 |             </template>
33 |         </parameters>
34 |     </easytabs>
35 | </widgets>
36 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/sql/easytabs_setup/upgrade-2.3.8-2.4.0.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /* @var $installer Mage_Core_Model_Resource_Setup */
 4 | $installer = $this;
 5 | 
 6 | $installer->startSetup();
 7 | 
 8 | /**
 9 |  * Create table 'easytabs/tab'
10 |  */
11 | $table = $installer->getConnection()
12 |     ->newTable($installer->getTable('easytabs/tab'))
13 |     ->addColumn('id', Varien_Db_Ddl_Table::TYPE_INTEGER, null, array(
14 |         'identity' => true,
15 |         'unsigned' => true,
16 |         'nullable' => false,
17 |         'primary'  => true
18 |         ), 'Tab Id')
19 |     ->addColumn('title', Varien_Db_Ddl_Table::TYPE_TEXT, 255, array(
20 |         'nullable'  => true
21 |         ), 'Title')
22 |     ->addColumn('alias', Varien_Db_Ddl_Table::TYPE_TEXT, 40, array(
23 |         'nullable'  => true
24 |         ), 'Alias')
25 |     ->addColumn('block', Varien_Db_Ddl_Table::TYPE_TEXT, 255, array(
26 |         'nullable'  => true
27 |         ), 'Block')
28 |     ->addColumn('custom_option', Varien_Db_Ddl_Table::TYPE_TEXT, 255, array(
29 |         'nullable'  => true
30 |         ), 'Custom Option')
31 |     ->addColumn('template', Varien_Db_Ddl_Table::TYPE_TEXT, 255, array(
32 |         'nullable'  => true
33 |         ), 'Template')
34 |     ->addColumn('unset', Varien_Db_Ddl_Table::TYPE_TEXT, 255, array(
35 |         'nullable'  => true
36 |         ), 'Unset')
37 |     ->addColumn('sort_order', Varien_Db_Ddl_Table::TYPE_INTEGER, null, array(
38 |         ), 'Sort Order')
39 |     ->addColumn('status', Varien_Db_Ddl_Table::TYPE_BOOLEAN, null, array()
40 |         , 'Status')
41 |     ->addColumn('product_tab', Varien_Db_Ddl_Table::TYPE_BOOLEAN, null, array()
42 |         , 'Product Tab')
43 |     ->addColumn('content', Varien_Db_Ddl_Table::TYPE_TEXT, null, array()
44 |         , 'Content')
45 |     ->setComment('Easy Tabs');
46 | $installer->getConnection()->createTable($table);
47 | 
48 | /**
49 |  * Create table 'easytabs/store'
50 |  */
51 | $table = $installer->getConnection()
52 |     ->newTable($installer->getTable('easytabs/store'))
53 |     ->addColumn('tab_id', Varien_Db_Ddl_Table::TYPE_INTEGER, null, array(
54 |         'nullable'  => false,
55 |         'unsigned' => true,
56 |         'primary'   => true,
57 |         ), 'Tab ID')
58 |     ->addColumn('store_id', Varien_Db_Ddl_Table::TYPE_SMALLINT, null, array(
59 |         'unsigned'  => true,
60 |         'nullable'  => false,
61 |         'primary'   => true,
62 |         ), 'Store ID')
63 |     ->addIndex($installer->getIdxName('easytabs/store', array('store_id')),
64 |         array('store_id'))
65 |     ->addForeignKey($installer->getFkName('easytabs/store', 'tab_id', 'easytabs/tab', 'id'),
66 |         'tab_id', $installer->getTable('easytabs/tab'), 'id',
67 |         Varien_Db_Ddl_Table::ACTION_CASCADE, Varien_Db_Ddl_Table::ACTION_CASCADE)
68 |     ->addForeignKey($installer->getFkName('easytabs/store', 'store_id', 'core/store', 'store_id'),
69 |         'store_id', $installer->getTable('core/store'), 'store_id',
70 |         Varien_Db_Ddl_Table::ACTION_CASCADE, Varien_Db_Ddl_Table::ACTION_CASCADE)
71 |     ->setComment('Tabs To Stores Linkage Table');
72 | $installer->getConnection()->createTable($table);
73 | 
74 | $installer->endSetup();
75 | 


--------------------------------------------------------------------------------
/app/code/community/TM/EasyTabs/sql/easytabs_setup/upgrade-3.0.3-3.1.0.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /* @var $installer Mage_Core_Model_Resource_Setup */
 4 | $installer = $this;
 5 | 
 6 | $installer->startSetup();
 7 | 
 8 | /**
 9 |  * Alter table 'easytabs/tab'
10 |  */
11 | $installer->getConnection()
12 |     ->addColumn(
13 |         $installer->getTable('easytabs/tab'),
14 |         'conditions_serialized',
15 |         array(
16 |             'type' => Varien_Db_Ddl_Table::TYPE_TEXT,
17 |             'length' => null,
18 |             'comment' => 'Conditions Serialized'
19 |         )
20 |     );
21 | 
22 | $installer->endSetup();
23 | 


--------------------------------------------------------------------------------
/app/design/adminhtml/default/default/layout/tm/easytabs.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <layout version="0.1.0">
  3 |     <adminhtml_easytabs_product_index>
  4 |         <reference name="content">
  5 |             <block type="easytabs/adminhtml_list" name="easytabs_list">
  6 |                 <action method="setTitle">
  7 |                     <title>Product Tabs</title>
  8 |                 </action>
  9 |                 <action method="setProductTab">
 10 |                     <value>1</value>
 11 |                 </action>
 12 |             </block>
 13 |         </reference>
 14 |     </adminhtml_easytabs_product_index>
 15 | 
 16 |      <adminhtml_easytabs_widget_index>
 17 |         <reference name="content">
 18 |             <block type="easytabs/adminhtml_list" name="easytabs_list">
 19 |                 <action method="setTitle">
 20 |                     <title>Widget Tabs</title>
 21 |                 </action>
 22 |                 <action method="setProductTab">
 23 |                     <value>0</value>
 24 |                 </action>
 25 |             </block>
 26 |         </reference>
 27 |      </adminhtml_easytabs_widget_index>
 28 | 
 29 |      <adminhtml_easytabs_widget_edit>
 30 |         <update handle="adminhtml_easytabs_product_edit"/>
 31 |      </adminhtml_easytabs_widget_edit>
 32 | 
 33 |      <adminhtml_easytabs_widget_loadtaboptions>
 34 |         <block name="easytabs.tab.options" type="easytabs/adminhtml_tab_options" output="toHtml" />
 35 |     </adminhtml_easytabs_widget_loadtaboptions>
 36 | 
 37 |     <adminhtml_easytabs_product_edit>
 38 |         <update handle="editor"/>
 39 |         <reference name="head">
 40 |             <action method="setCanLoadExtJs"><flag>1</flag></action>
 41 |             <action method="setCanLoadRulesJs"><flag>1</flag></action>
 42 |         </reference>
 43 |         <reference name="js">
 44 |             <block type="core/template" template="catalog/wysiwyg/js.phtml" name="catalog.wysiwyg.js" />
 45 |         </reference>
 46 |         <reference name="content">
 47 |             <block type="easytabs/adminhtml_edit" name="easytabs_edit"/>
 48 |         </reference>
 49 |         <reference name="left">
 50 |             <block type="easytabs/adminhtml_edit_tabs" name="easytabs_edit_tabs">
 51 |                 <block type="easytabs/adminhtml_edit_tab_main" name="easytabs_edit_tab_main" />
 52 |                 <block type="easytabs/adminhtml_edit_tab_conditions" name="easytabs_edit_tab_conditions" />
 53 |                 <action method="addTab">
 54 |                     <name>main_section</name>
 55 |                     <block>easytabs_edit_tab_main</block>
 56 |                 </action>
 57 |                 <action method="addTab">
 58 |                     <name>conditions_section</name>
 59 |                     <block>easytabs_edit_tab_conditions</block>
 60 |                 </action>
 61 |             </block>
 62 |         </reference>
 63 |     </adminhtml_easytabs_product_edit>
 64 | 
 65 |     <adminhtml_easytabs_product_loadTabOptions>
 66 |         <block name="easytabs.tab.options" type="easytabs/adminhtml_tab_options" output="toHtml" />
 67 |     </adminhtml_easytabs_product_loadTabOptions>
 68 | 
 69 |     <adminhtml_easytabs_product_loadtaboptions>
 70 |         <block name="easytabs.tab.options" type="easytabs/adminhtml_tab_options" output="toHtml" />
 71 |     </adminhtml_easytabs_product_loadtaboptions>
 72 | 
 73 |     <editor>
 74 |         <reference name="head">
 75 |             <action method="addItem">
 76 |                 <type>js_css</type>
 77 |                 <name>tm/lib/chosen/chosen.css</name>
 78 |             </action>
 79 |             <action method="addItem">
 80 |                 <type>js</type>
 81 |                 <name>tm/lib/chosen/chosen.proto.js</name>
 82 |             </action>
 83 |         </reference>
 84 |     </editor>
 85 | 
 86 |     <adminhtml_widget_instance_edit>
 87 |         <reference name="head">
 88 |             <action method="addItem">
 89 |                 <type>js_css</type>
 90 |                 <name>tm/lib/chosen/chosen.css</name>
 91 |             </action>
 92 |             <action method="addItem">
 93 |                 <type>js</type>
 94 |                 <name>tm/lib/chosen/chosen.proto.js</name>
 95 |             </action>
 96 |         </reference>
 97 |     </adminhtml_widget_instance_edit>
 98 | 
 99 | </layout>
100 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/layout/tm/easytabs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <layout version="0.1.0">
 3 | 
 4 |     <default>
 5 |         <reference name="head">
 6 |             <action method="addItem" ifconfig="tm_easytabs/general/enabled">
 7 |                 <type>skin_css</type>
 8 |                 <name>tm/easytabs/css/styles.css</name>
 9 |             </action>
10 |             <action method="addItem" ifconfig="tm_easytabs/general/enabled">
11 |                 <type>skin_js</type>
12 |                 <name>tm/easytabs/js/prototype.sticky-kit.js</name>
13 |                 <params>defer</params>
14 |             </action>
15 |             <action method="addItem" ifconfig="tm_easytabs/general/enabled">
16 |                 <type>skin_js</type>
17 |                 <name>tm/easytabs/js/main.js</name>
18 |                 <params>defer</params>
19 |             </action>
20 |         </reference>
21 |         <reference name="tmamp.styles">
22 |             <action method="addItem"><name>tm/easytabs/css/tmamp</name></action>
23 |         </reference>
24 |     </default>
25 | 
26 |     <catalog_product_view>
27 |         <reference name="head">
28 |             <action method="addItem" ifconfig="tm_easytabs/general/enabled">
29 |                 <type>skin_js</type>
30 |                 <name>tm/easytabs/js/product.js</name>
31 |                 <params>defer</params>
32 |             </action>
33 |         </reference>
34 |         <reference name="product.info.additional">
35 |             <block type="easytabs/product" name="product.info.tabs" as="info_tabs">
36 |                 <action method="setTemplate" ifconfig="tm_easytabs/general/enabled">
37 |                     <template>tm/easytabs/tabs.phtml</template>
38 |                 </action>
39 |             </block>
40 |         </reference>
41 |     </catalog_product_view>
42 | 
43 |     <tmamp_catalog_product_view>
44 |         <reference name="product.info">
45 |             <block type="easytabs/product" name="product.info.tabs" as="product_additional_data">
46 |                 <action method="setTemplate" ifconfig="tm_easytabs/general/enabled">
47 |                     <template>tm/easytabs/tabs.phtml</template>
48 |                 </action>
49 |             </block>
50 |         </reference>
51 |     </tmamp_catalog_product_view>
52 | 
53 | </layout>
54 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/template/tm/easytabs/tab/catalog/product/attribute.phtml:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 |     $attributeCode = $this->getAttributeCode();
 4 |     $product = $this->getProduct();
 5 | 
 6 |     if(!$attributeCode || !$product) {
 7 |         return;
 8 |     }
 9 |     $attribute = $product->getResource()->getAttribute($attributeCode);
10 |     if (!$attribute) {
11 |         return;
12 |     }
13 |     $content = $attribute->getFrontend()->getValue($product);
14 |     if(empty($content)) {
15 |         $content = $attribute->getDefaultValue();
16 |     }
17 |     if(empty($content)) {
18 |         return;
19 |     }
20 |     $_helper = $this->helper('catalog/output');
21 | ?>
22 |     <div class="product-specs">
23 |     <?php echo $_helper->productAttribute(
24 |         $this->getProduct(), $content, $attributeCode
25 |     )?>
26 |     </div>
27 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/template/tm/easytabs/tab/catalog/product/view/attributes.phtml:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Product additional attributes template
 4 |  *
 5 |  * @see TM_EasyTabs_Block_Tab_Product_Additional
 6 |  */
 7 | ?>
 8 | <?php
 9 |     $_helper = $this->helper('catalog/output');
10 |     $_product = $this->getProduct()
11 | ?>
12 | <?php if($_additional = $this->getAdditionalData()):
13 |     $_prevGroupId = -1;
14 | ?>
15 | <div class="box-collateral box-additional">
16 | <?php foreach ($_additional as $_data): ?>
17 |     <?php $_groupId = isset($_data['group']) ? $_data['group']['id'] : 0; ?>
18 |     <?php if ($_groupId != $_prevGroupId) : ?>
19 |         <?php echo ($_prevGroupId != -1) ? '</tbody></table>' : '';?>
20 |         <?php $_prevGroupId = $_groupId; ?>
21 |     <table class="data-table">
22 |         <caption class="h2">
23 |             <?php echo $this->__($this->getIsGrouped() ? $_data['group']['name'] : '');?>
24 |         </caption>
25 |         <col width="25%" />
26 |         <col />
27 |         <tbody>
28 |     <?php endif; ?>
29 |     <?php
30 |         $_label = $this->htmlEscape($this->__($_data['label']));
31 |         $_value = $_helper
32 |             ->productAttribute($_product, $_data['value'], $_data['code']);
33 |     ?>
34 |             <tr>
35 |                 <th class="label"><?php echo $_label ?></th>
36 |                 <td class="data"><?php echo $_value ?></td>
37 |             </tr>
38 | <?php endforeach; ?>
39 |         </tbody>
40 |     </table>
41 | </div>
42 | <?php endif;?>
43 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/template/tm/easytabs/tab/catalog/product/view/description.phtml:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Product description template
 4 |  *
 5 |  * @see TM_EasyTabs_Block_Tab_Product_Description
 6 |  */
 7 | ?>
 8 | <?php $_description = $this->getProduct()->getDescription(); ?>
 9 | <?php if ($_description): ?>
10 |     <div class="std">
11 |         <?php echo $this->helper('catalog/output')->productAttribute($this->getProduct(), $_description, 'description') ?>
12 |     </div>
13 | <?php endif; ?>
14 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/template/tm/easytabs/tab/cms.phtml:
--------------------------------------------------------------------------------
 1 | <?php
 2 |     $id = $this->getCmsBlockId();
 3 |     if (empty($id)) {
 4 |         return;
 5 |     }
 6 |     ?>
 7 | <div class="product-specs">
 8 |     <?php
 9 |         echo $this->getLayout()
10 |             ->createBlock('cms/block')
11 |             ->setBlockId($id)
12 |             ->toHtml();
13 |     ?>
14 | </div>
15 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/template/tm/easytabs/tab/review/product/view/list.phtml:
--------------------------------------------------------------------------------
1 | <?php echo $this->getLayout()
2 |     ->createBlock('review/product_view_list')
3 |     ->setTemplate('review/product/view/list.phtml')
4 |     ->toHtml();
5 | ?>
6 | 
7 | <?php echo $this->getChildHtml('review_form') ?>
8 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/template/tm/easytabs/tab/tag/product/list.phtml:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Magento
 4 |  *
 5 |  * NOTICE OF LICENSE
 6 |  *
 7 |  * This source file is subject to the Academic Free License (AFL 3.0)
 8 |  * that is bundled with this package in the file LICENSE_AFL.txt.
 9 |  * It is also available through the world-wide-web at this URL:
10 |  * http://opensource.org/licenses/afl-3.0.php
11 |  * If you did not receive a copy of the license and are unable to
12 |  * obtain it through the world-wide-web, please send an email
13 |  * to license@magentocommerce.com so we can send you a copy immediately.
14 |  *
15 |  * DISCLAIMER
16 |  *
17 |  * Do not edit or add to this file if you wish to upgrade Magento to newer
18 |  * versions in the future. If you wish to customize Magento for your
19 |  * needs please refer to http://www.magentocommerce.com for more information.
20 |  *
21 |  * @category    design
22 |  * @package     base_default
23 |  * @copyright   Copyright (c) 2009 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
24 |  * @license     http://opensource.org/licenses/afl-3.0.php  Academic Free License (AFL 3.0)
25 |  */
26 | ?>
27 | <div class="box-collateral box-tags">
28 |     <?php echo $this->getChildHtml('list_before')?>
29 |     <?php if( $this->getCount() ): ?>
30 |     <h3><?php echo $this->__('Other people marked this product with these tags:') ?></h3>
31 |     <ul class="product-tags">
32 |         <?php $_iterator = 0; ?>
33 |         <?php foreach( $this->getTags() as $_tag ): ?>
34 |             <li<?php if( 1 == ++$_iterator && $this->getCount() != 1 ): ?> class="first"<?php elseif($_iterator == $this->getCount()): ?> class="last"<?php endif; ?>><a href="<?php echo $_tag->getTaggedProductsUrl() ?>"><?php echo $this->htmlEscape($_tag->getName()) ?></a> (<?php echo $_tag->getPopularity() ?>)</li>
35 |         <?php endforeach; ?>
36 |     </ul>
37 |     <?php endif; ?>
38 |     <form id="addTagForm" action="<?php echo $this->getFormAction(); ?>" method="get">
39 |         <div class="form-add">
40 |             <label for="productTagName"><?php echo $this->__('Add Your Tags:') ?></label>
41 |             <div class="input-box">
42 |                 <input type="text" class="input-text required-entry" name="productTagName" id="productTagName" />
43 |             </div>
44 |             <button type="button" title="<?php echo $this->__('Add Tags') ?>" class="button" onclick="submitTagForm()"><span><span><?php echo $this->__('Add Tags') ?></span></span></button>
45 |         </div>
46 |     </form>
47 |     <p class="note"><?php echo $this->__("Use spaces to separate tags. Use single quotes (') for phrases.") ?></p>
48 | </div>
49 | 


--------------------------------------------------------------------------------
/app/design/frontend/base/default/template/tm/easytabs/tabs.phtml:
--------------------------------------------------------------------------------
 1 | <?php
 2 |     $tabs = array();
 3 |     foreach ($this->getTabs() as $_index => $_tab) {
 4 |         if (!($childHtml = $this->getChildHtml($_tab['alias']))
 5 |             || $this->isEmptyString($childHtml)) {
 6 | 
 7 |             continue;
 8 |         }
 9 |         $_tab['child_html'] = $childHtml;
10 | 
11 |         $tabs[$_index] = $_tab;
12 |     }
13 |     $tabClasses = 'easytabs-anchor easytabs-a easytabs-a-tab'
14 |         . ($this->isExpandedLayout() ? ' easytabs-animate easytabs-scroll' : '');
15 | ?>
16 | <div class="easytabs-wrapper <?php echo $this->getTabsLayout(); ?>" id="<?php echo $this->getHtmlId();?>" <?php echo $this->getUpdateUrlHash() ? 'data-track-hash' : ''; ?> <?php echo $this->getInitiallyCollapsed() ? 'data-collapsed' : ''; ?> <?php echo $this->getStickyTabs() ? 'data-sticky-tabs' : ''; ?>>
17 |     <?php if (!$this->isExpandedLayout() || $this->getStickyTabs()): ?>
18 |     <div class="easytabs-ul-wrapper">
19 |         <ul class="easytabs">
20 |             <?php foreach ($tabs as $_index => $_tab) : ?>
21 |                 <li>
22 |                     <h2 class="tab-title" >
23 |                         <?php if ($this->getUpdateUrlHash() == 1) : ?>
24 |                             <a href="#product_tabs_<?php echo $_tab['alias'] ?>" class="<?php echo $tabClasses; ?>">
25 |                                 <?php echo $this->getTabTitle($_tab); ?>
26 |                             </a>
27 |                         <?php else : ?>
28 |                             <span data-href="#product_tabs_<?php echo $_tab['alias'] ?>" class="<?php echo $tabClasses; ?>">
29 |                                 <?php if ($this->getShowAnchor()) : ?>
30 |                                     <a href="#product_tabs_<?php echo $_tab['alias'] ?>" class="easytabs-anchor-icon">#</a>
31 |                                 <?php endif ?>
32 |                                 <?php echo $this->getTabTitle($_tab); ?>
33 |                             </span>
34 |                         <?php endif ?>
35 |                     </h2>
36 |                 </li>
37 |             <?php endforeach; ?>
38 |         </ul>
39 |     </div>
40 |     <?php endif ?>
41 |     <div class="padder easytabs-content-wrapper">
42 |     <?php foreach ($tabs as $_index => $_tab) : ?>
43 |         <div class="tab-wrapper" data-tab="<?php echo $_tab['alias'] ?>">
44 |             <span data-href="#product_tabs_<?php echo $_tab['alias'] ?>" class="<?php echo $this->isExpandedLayout() ? 'h2 easytabs-animate easytabs-scroll' : ' easytabs-a-accordion easytabs-a'?> easytabs-anchor">
45 |                 <?php echo $this->getTabTitle($_tab);?>
46 |             </span>
47 |             <div class="easytabs-content"
48 |                 id="product_tabs_<?php echo $_tab['alias'] ?>_contents"
49 |                 data-tab-alias="<?php echo $_tab['alias'] ?>"
50 |                 <?php if (!$this->isExpandedLayout()): ?> style="display:none"<?php endif; ?>>
51 |                 <?php echo $_tab['child_html']; ?>
52 |             </div>
53 |         </div>
54 |     <?php endforeach; ?>
55 |     </div>
56 | </div>
57 | 


--------------------------------------------------------------------------------
/app/design/frontend/tmamp/default/template/tm/easytabs/tabs.phtml:
--------------------------------------------------------------------------------
 1 | <?php
 2 |     $tabs = array();
 3 |     foreach ($this->getTabs() as $_index => $_tab) {
 4 |         if (!($childHtml = $this->getChildHtml($_tab['alias']))
 5 |             || $this->isEmptyString($childHtml)) {
 6 | 
 7 |             continue;
 8 |         }
 9 |         $_tab['child_html'] = $childHtml;
10 | 
11 |         $tabs[$_index] = $_tab;
12 |     }
13 | ?>
14 | <amp-accordion class="collateral-tabs" animate>
15 | <?php foreach ($tabs as $_index => $_tab) : ?>
16 |     <section expanded>
17 |         <h5 id="#product_tabs_<?php echo $_tab['alias'] ?>" class="tab">
18 |             <?php echo $this->getTabTitle($_tab);?>
19 |         </h5>
20 |         <div id="product_tabs_<?php echo $_tab['alias'] ?>_contents" class="tab-container">
21 |             <div class="tab-content"><?php echo $_tab['child_html']; ?></div>
22 |         </div>
23 |     </section>
24 | <?php endforeach; ?>
25 | </amp-accordion>
26 | 


--------------------------------------------------------------------------------
/app/etc/modules/TM_EasyTabs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <config>
 3 |     <modules>
 4 |         <TM_EasyTabs>
 5 |             <active>true</active>
 6 |             <codePool>community</codePool>
 7 |             <tm_link><![CDATA[http://templates-master.com/magento-extensions/magento-easy-tabs.html]]></tm_link>
 8 |             <depends>
 9 |                 <Mage_Catalog />
10 |             </depends>
11 |         </TM_EasyTabs>     
12 |     </modules>
13 | </config>


--------------------------------------------------------------------------------
/app/locale/el_GR/TM_EasyTabs.csv:
--------------------------------------------------------------------------------
 1 | "Check items to add to the cart or","Επιλέξτε αντικείμενα για προσθήκη στην κάρτα ή"
 2 | "Add to Wishlist","Προσθήκη στη λίστα επιθυμιών"
 3 | "Review by %s","Κριτική από %s"
 4 | "(Posted on %s)","(Αναρτήθηκε στις %s)"
 5 | "Other people marked this product with these tags:","Άλλοι σημείωσαν το προϊόν με τις παρακάτω ετικέτες:"
 6 | "Add Your Tags:","Προσθέστε τις ετικέτες σας:"
 7 | "Add Tags","Προσθήκη ετικετών"
 8 | "Use spaces to separate tags. Use single quotes (') for phrases.","Χρησιμοποιήστε το διάστημα (space) για να διαχωρήσετε τις ετικέτες. Χρησιμοποιείστε μονό εισαγωγικό (') για φράσεις."
 9 | "Email to a Friend","Email σε κάποιον φίλο"
10 | "Update url when switch between tabs","Ενημερώνεται το url (διεύθυνση) κατά την εναλλαγή καρτέλων (tab)"
11 | "Show tab anchor when hovering tab","Εμφάνιση άγκυρας σε καρτέλα κατά την εναλλαγή καρτελών"


--------------------------------------------------------------------------------
/app/locale/en_US/TM_EasyTabs.csv:
--------------------------------------------------------------------------------
 1 | "Check items to add to the cart or","Check items to add to the cart or"
 2 | "Add to Wishlist","Add to Wishlist"
 3 | "Review by %s","Review by %s"
 4 | "(Posted on %s)","(Posted on %s)"
 5 | "Other people marked this product with these tags:","Other people marked this product with these tags:"
 6 | "Add Your Tags:","Add Your Tags:"
 7 | "Add Tags","Add Tags"
 8 | "Use spaces to separate tags. Use single quotes (') for phrases.","Use spaces to separate tags. Use single quotes (') for phrases."
 9 | "Email to a Friend","Email to a Friend"
10 | "Update url when switch between tabs","Update url when switch between tabs"
11 | "Show tab anchor when hovering tab","Show tab anchor when hovering tab"
12 | 


--------------------------------------------------------------------------------
/app/locale/es_ES/TM_EasyTabs.csv:
--------------------------------------------------------------------------------
 1 | "General","General"
 2 | "Enable easy tabs","Habilitar banderas fáciles "
 3 | "Check items to add to the cart or","Comprueba los artículos para añadirlos a la cesta o"
 4 | "Add to Wishlist","Agregar a la lista de peticiones"
 5 | "Review by %s","Revisado por % s"
 6 | "(Posted on %s)","(Publicado en% s)"
 7 | "Other people marked this product with these tags:","Otras personas marcaron este producto con las siguientes etiquetas:"
 8 | "Add Your Tags:","Agregar tus etiquetas:"
 9 | "Add Tags","Agregar etiquetas"
10 | "Use spaces to separate tags. Use single quotes (') for phrases.","Utilizar espacios para separar las etiquetas. Usar comillas simples ( ') para frases."
11 | "Email to a Friend","Enviar a un amigo"
12 | 


--------------------------------------------------------------------------------
/app/locale/fr_FR/TM_EasyTabs.csv:
--------------------------------------------------------------------------------
 1 | "General","Général"
 2 | "Enable easy tabs","Activer les flags simples"
 3 | "Check items to add to the cart or","Contrôler les objets à ajouter au panier ou"
 4 | "Add to Wishlist","Ajouter à la liste de souhaits"
 5 | "Review by %s","Evalué par %"
 6 | "(Posted on %s)","(Publié sur %)"
 7 | "Other people marked this product with these tags:","D'autres personnes ont identifié ce produit avec ces tags: "
 8 | "Add Your Tags:","Ajouter vos Tags:"
 9 | "Add Tags","Ajouter des Tags:"
10 | "Use spaces to separate tags. Use single quotes (') for phrases.","Utiliser des espaces pour séparer les tags. Entrer une simple citation (') pour les phrases."
11 | "Email to a Friend","Transmettre par courriel à un ami"
12 | 


--------------------------------------------------------------------------------
/app/locale/it_IT/TM_EasyTabs.csv:
--------------------------------------------------------------------------------
 1 | "General","Generale"
 2 | "Enable easy tabs","Attiva easy flags"
 3 | "Check items to add to the cart or","Controlla oggetti da aggiungere al carrello o"
 4 | "Add to Wishlist","Aggiungi alla Lista dei Desideri"
 5 | "Review by %s","Recensione di %s"
 6 | "(Posted on %s)","(Pubblicato su %s)"
 7 | "Other people marked this product with these tags:","Altre persone hanno marcato il prodotto con queste tag:"
 8 | "Add Your Tags:","Aggiungi le Tue Tag:"
 9 | "Add Tags","Aggiungi Tag"
10 | "Use spaces to separate tags. Use single quotes (') for phrases.","Usa gli spazi per separare le tag. usa gli apici (') per le frasi."
11 | "Email to a Friend","Invia una Email ad un amico"
12 | 


--------------------------------------------------------------------------------
/app/locale/nl_NL/TM_EasyTabs.csv:
--------------------------------------------------------------------------------
 1 | "General","Algemeen"
 2 | "Enable easy tabs","Maak easy tabs mogelijk"
 3 | "Check items to add to the cart or","Check items om aan het winkelwagentje toe te voegen of"
 4 | "Add to Wishlist","Voeg toe aan het verlanglijstje"
 5 | "Review by %s","Beoordeling door %s"
 6 | "(Posted on %s)","(Geplaatst op %s)"
 7 | "Other people marked this product with these tags:","Andere mensen hebben dit product aangeduid met deze tags:"
 8 | "Add Your Tags:","Voeg je Tags toe:"
 9 | "Add Tags","VoegTags toe"
10 | "Use spaces to separate tags. Use single quotes (') for phrases.","Gebruik spaties om tags te scheiden. Gebruik enkele aanhalingstekens voor(') zinnen. "
11 | "Email to a Friend","Email naar een vriend"
12 | 


--------------------------------------------------------------------------------
/app/locale/pt_PT/TM_EasyTabs.csv:
--------------------------------------------------------------------------------
 1 | "General","Geral"
 2 | "Enable easy tabs","Permitir bandeiras fáceis"
 3 | "Check items to add to the cart or","Verifique itens para adicionar ao carrinho ou"
 4 | "Add to Wishlist","Adicionar à lista de desejos"
 5 | "Review by %s","Revisado por %s"
 6 | "(Posted on %s)","(Postado em %s)"
 7 | "Other people marked this product with these tags:","Outras pessoas marcaram este produto com estas tags:"
 8 | "Add Your Tags:","Add Suas Tags:"
 9 | "Add Tags","Add Tags"
10 | "Use spaces to separate tags. Use single quotes (') for phrases.","Use espaços para separar tags. Use aspas simples (') para frases."
11 | "Email to a Friend","E-mail para um amigo"
12 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "tm/easytabs",
 3 |     "type": "magento-module",
 4 |     "homepage": "https://github.com/tmhub/easytabs",
 5 |     "license": "OSL-3.0",
 6 |     "description": "Tabs for product page",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Template Masters Team",
10 |             "email": "support@templates-master.com"
11 |         }
12 |     ],
13 |     "require": {
14 |         "tm/core": "*"
15 |     },
16 |     "extra": {
17 |         "tm": {
18 |             "links": {
19 |                 "download"  : "https://swissuplabs.com/product-tabs-magento-extension.html",
20 |                 "docs"      : "http://docs.swissuplabs.com/m1/extensions/easytabs/",
21 |                 "changelog" : "http://docs.swissuplabs.com/m1/extensions/easytabs/changelog/"
22 |             }
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/modman:
--------------------------------------------------------------------------------
 1 | app/code/community/TM/EasyTabs                              app/code/community/TM/EasyTabs
 2 | app/design/adminhtml/default/default/layout/tm/easytabs.xml app/design/adminhtml/default/default/layout/tm/easytabs.xml
 3 | app/design/frontend/base/default/layout/tm/easytabs.xml     app/design/frontend/base/default/layout/tm/easytabs.xml
 4 | app/design/frontend/base/default/template/tm/easytabs       app/design/frontend/base/default/template/tm/easytabs
 5 | app/design/frontend/tmamp/default/template/tm/easytabs      app/design/frontend/tmamp/default/template/tm/easytabs
 6 | app/etc/modules/TM_EasyTabs.xml                             app/etc/modules/TM_EasyTabs.xml
 7 | app/locale/en_US/TM_EasyTabs.csv                            app/locale/en_US/TM_EasyTabs.csv
 8 | app/locale/es_ES/TM_EasyTabs.csv                            app/locale/es_ES/TM_EasyTabs.csv
 9 | app/locale/fr_FR/TM_EasyTabs.csv                            app/locale/fr_FR/TM_EasyTabs.csv
10 | app/locale/it_IT/TM_EasyTabs.csv                            app/locale/it_IT/TM_EasyTabs.csv
11 | app/locale/nl_NL/TM_EasyTabs.csv                            app/locale/nl_NL/TM_EasyTabs.csv
12 | app/locale/pt_PT/TM_EasyTabs.csv                            app/locale/pt_PT/TM_EasyTabs.csv
13 | skin/frontend/base/default/tm/easytabs                      skin/frontend/base/default/tm/easytabs
14 | skin/adminhtml/default/default/images/widget/easytabs__widget.gif  skin/adminhtml/default/default/images/widget/easytabs__widget.gif
15 | 


--------------------------------------------------------------------------------
/skin/adminhtml/default/default/images/widget/easytabs__widget.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tmhub/easytabs/8e9aa332e7efa53e297f6e9de266ce32005bc126/skin/adminhtml/default/default/images/widget/easytabs__widget.gif


--------------------------------------------------------------------------------
/skin/adminhtml/default/default/images/widget/easytabs__widget_2.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tmhub/easytabs/8e9aa332e7efa53e297f6e9de266ce32005bc126/skin/adminhtml/default/default/images/widget/easytabs__widget_2.gif


--------------------------------------------------------------------------------
/skin/adminhtml/default/default/images/widget/easytabs__widget_transparent.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tmhub/easytabs/8e9aa332e7efa53e297f6e9de266ce32005bc126/skin/adminhtml/default/default/images/widget/easytabs__widget_transparent.png


--------------------------------------------------------------------------------
/skin/frontend/base/default/tm/easytabs/css/styles.css:
--------------------------------------------------------------------------------
  1 | .easytabs-wrapper { margin: 0 0 20px; }
  2 | .std ul.easytabs, .easytabs {
  3 |     display: inline-table;
  4 |     vertical-align: top;
  5 |     margin: 0 0 0 -5px;
  6 |     padding: 0;
  7 |     border-spacing: 5px 0;
  8 |     position: relative;
  9 |     z-index: 6;
 10 |     /*width: 100%; box-sizing: border-box; -moz-box-sizing: border-box; */
 11 | }
 12 | .easytabs li { display: table-cell; text-align: center; vertical-align: middle; }
 13 | .easytabs li,
 14 | .easytabs-a-accordion {
 15 |     line-height: normal;
 16 |     background: #eaeaea;
 17 |     border: 1px solid #ccc;
 18 |     box-shadow: inset 0 -12px 8px -14px rgba(0, 0, 0, 0.2);
 19 | }
 20 | .easytabs li:hover { box-shadow: none; }
 21 | .easytabs li .easytabs-anchor-icon:hover,
 22 | .easytabs-a-accordion:hover { text-decoration: none; }
 23 | .easytabs li.active {
 24 |     background: #fbfbfb;
 25 |     border-width: 1px 1px 0;
 26 |     box-shadow: none;
 27 |     text-shadow: 0px 1px 1px rgba(255,255,255, 0.6);
 28 | }
 29 | 
 30 | .easytabs .tab-title {
 31 |     margin: 0;
 32 |     padding: 0;
 33 |     font-size: inherit;
 34 |     text-transform: none;
 35 | }
 36 | 
 37 | .easytabs-a {
 38 |     display: block;
 39 |     padding: 9px 12px;
 40 |     cursor: pointer;
 41 | }
 42 | .easytabs-a,
 43 | .easytabs-a .easytabs-anchor-icon {
 44 |     color: #777;
 45 |     text-decoration: none;
 46 |     text-shadow: 1px 1px 1px rgba(255,255,255,0.8);
 47 |     font: bold 12px/16px Arial, Helvetica, Tahoma, sans-serif;
 48 | }
 49 | .easytabs-a .easytabs-anchor-icon:hover {
 50 |     color: #777;
 51 |     text-decoration: none;
 52 | }
 53 | .easytabs-content {
 54 |     padding: 7px 8px;
 55 |     border: 1px solid #ccc;
 56 |     position: relative;
 57 |     margin-top: -1px;
 58 |     background: #fbfbfb;
 59 | }
 60 | .easytabs-wrapper:not(.expanded) .easytabs-content {
 61 |     z-index: 5;
 62 | }
 63 | .easytabs-a-accordion { margin-top: -1px; background: #f1f1f1; display: none; padding: 12px; }
 64 | .easytabs-a-accordion.active { box-shadow: none; color: #48494a; }
 65 | 
 66 | .easytabs-a .easytabs-anchor-icon {
 67 |     font-size: 12px;
 68 |     height: 16px;
 69 |     width: 10px;
 70 |     margin-left: -10px;
 71 |     float: left;
 72 |     opacity: 0.7;
 73 |     visibility: hidden;
 74 |     text-decoration: none;
 75 | }
 76 | .easytabs-a:hover .easytabs-anchor-icon { visibility: visible; }
 77 | .easytabs-a .easytabs-anchor-icon:hover { opacity: 1; }
 78 | 
 79 | .easytabs-content .box-collateral { margin: 0; }
 80 | .easytabs-content .box-up-sell .products-grid td { padding-left: 7px; padding-right: 7px; }
 81 | .easytabs-content .block-related .block-title { display: none; }
 82 | #product_tabs_tags_tabbed_contents label { display: block; }
 83 | #product_tabs_tags_tabbed_contents .input-box input { width: 300px; }
 84 | #product_tabs_tags_tabbed_contents .input-box { width: 300px; float:left; margin: 0 10px 3px 0;}
 85 | #product_tabs_related_tabbed_contents ol { clear: both; }
 86 | #product_tabs_related_tabbed_contents li { float:left; margin: 0 1% 15px 0; width: 31%; }
 87 | #product_tabs_related_tabbed_contents li:nth-child(1n) { width: 32%; }
 88 | #product_tabs_related_tabbed_contents li:nth-child(3n) { margin-right: 0; }
 89 | #product_tabs_related_tabbed_contents li:nth-child(3n+1) { clear: left; }
 90 | #product_tabs_related_tabbed_contents .product-images { float: left; }
 91 | #product_tabs_related_tabbed_contents .product-images a { margin: 0 0 0 5px; }
 92 | #product_tabs_related_tabbed_contents .product-details { margin-left: 75px; }
 93 | #product_tabs_related_tabbed_contents .price-box { margin: 0; }
 94 | 
 95 | .easytabs,
 96 | .easytabs-content,
 97 | .product-collateral,
 98 | .easytabs-content .form-add { zoom: 1; }
 99 | .easytabs:after,
100 | .easytabs-content:after,
101 | .product-collateral:after,
102 | .easytabs-content .form-add:after { content: '.'; visibility: hidden; clear: both; display: block; height: 0; font-size: 0; }
103 | 
104 | .easytabs-content .data-table caption { margin-top: 20px; }
105 | .easytabs-content .data-table:first-child caption { margin-top: 0; }
106 | 
107 | .easytabs-wrapper .easytabs-ul-wrapper.is_stuck { z-index: 900; background: #fff; }
108 | .easytabs-wrapper:not(.expanded) .easytabs-ul-wrapper.is_stuck { box-shadow: inset 0 -1px 0 #ccc; }
109 | .easytabs-wrapper.expanded .easytabs-ul-wrapper.is_stuck::before {
110 |     background: #fff;
111 |     box-shadow: 0 4px 2px -2px rgba(0,0,0,.15);
112 |     content: ' ';
113 |     position: absolute;
114 |     left: -100vw;
115 |     height: 100%;
116 |     width: 200vw;
117 | }
118 | /* style below prevents horisontall scroll; at Argento Luxury scroll appears when scticky parent our of screen */
119 | .easytabs-wrapper.expanded .easytabs-ul-wrapper.is_stuck[style*="absolute"]::before { display: none; }
120 | .easytabs-wrapper.expanded .easytabs-ul-wrapper.is_stuck .easytabs li { background: none; border: none; box-shadow: none; }
121 | 
122 | .easytabs-wrapper.expanded .easytabs-ul-wrapper { visibility: hidden; }
123 | .easytabs-wrapper.expanded .easytabs-ul-wrapper.is_stuck { visibility: visible; }
124 | .easytabs-wrapper.expanded .tab-wrapper { display: flex; border-top: 1px solid #ccc;}
125 | .easytabs-wrapper.expanded .tab-wrapper:last-child { border-bottom: 1px solid #ccc;}
126 | .easytabs-wrapper.expanded .tab-wrapper .easytabs-anchor,
127 | .easytabs-wrapper.expanded .tab-wrapper .easytabs-content {
128 |     flex: 1;
129 |     display: block;
130 |     border: none;
131 |     padding-top: 20px;
132 |     padding-bottom: 20px;
133 |     margin-top: 0;
134 | }
135 | .easytabs-wrapper.expanded .tab-wrapper .easytabs-content { flex: 3; }
136 | 
137 | @media (max-width: 768px) {
138 |     .easytabs-wrapper.expanded .tab-wrapper { display: block; }
139 |     .easytabs-wrapper.expanded .tab-wrapper .easytabs-content { border-top: none; padding-top: 0; }
140 | }
141 | 
142 | @media (max-width: 480px) {
143 |     /*
144 |      * .easytabs-a-tab should be hidden.
145 |      * See the easytabs.js~12: el.getStyle('display') !== 'none'
146 |      */
147 |     .std ul.easytabs, .easytabs, .easytabs-a-tab { display: none; }
148 |     .easytabs-a-accordion { display: block; }
149 | 
150 |     #product_tabs_tags_tabbed_contents .input-box input { width: 200px; }
151 |     #product_tabs_tags_tabbed_contents .input-box { width: 200px; }
152 | 
153 |     #product_tabs_related_tabbed_contents li { float:none; margin: 0 0 10px; width: auto; }
154 |     #product_tabs_related_tabbed_contents li:nth-child(1n) { width: auto; }
155 | 
156 |     #product_tabs_review_tabbed_contents .ratings .rating-box {
157 |         background: rgba(0, 0, 0, 0) none repeat scroll 0 0;
158 |         height: 19.6px;
159 |         text-align: center;
160 |         text-indent: 0;
161 |         width: 100%;
162 |     }
163 | 
164 |     #product_tabs_review_tabbed_contents .ratings .rating-box .rating {
165 |         display: none;
166 |     }
167 |     #product_tabs_review_tabbed_contents .ratings .rating-box .rating-number {
168 |         display: inline-block;
169 |     }
170 | }
171 | 


--------------------------------------------------------------------------------
/skin/frontend/base/default/tm/easytabs/css/tmamp.scss:
--------------------------------------------------------------------------------
 1 | amp-accordion.collateral-tabs {
 2 |     .tab {
 3 |         position: relative;
 4 | 
 5 |         &::after {
 6 |             border-style: solid;
 7 |             border-width: 0 0 2px 2px;
 8 |             content: '';
 9 |             display: block;
10 |             height: 8px;
11 |             position: absolute;
12 |             vertical-align: top;
13 |             width: 8px;
14 |             right: 15px;
15 |             transform: rotate(135deg);
16 |             top: 25px;
17 |         }
18 | 
19 |         &[aria-expanded=true]::after {
20 |             top: 20px;
21 |             transform: rotate(-45deg);
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/skin/frontend/base/default/tm/easytabs/js/main.js:
--------------------------------------------------------------------------------
  1 | var EasyTabs = Class.create();
  2 | EasyTabs.prototype = {
  3 |     tpl: {
  4 |         tab    : '(.+)?',
  5 |         href   : '#product_tabs_(.+)?',
  6 |         content: 'product_tabs_(.+)?_contents'
  7 |     },
  8 |     config: {
  9 |         tabs     : '.easytabs-anchor',
 10 |         scrollSpeed: 0.5,
 11 |         scrollOffset: -5
 12 |     },
 13 | 
 14 |     initialize: function(container, options) {
 15 |         Object.extend(this.config, options || {});
 16 |         this.container = container;
 17 |         this.activeTabs = [];
 18 |         this.counters = {}; // Activity counters
 19 | 
 20 |         var isActivateFirstTab = !this.isExpandedLayout()
 21 |             && !this.container.hasAttribute('data-collapsed');
 22 | 
 23 |         if (this.container.hasAttribute("data-track-hash") && window.location.hash.length > 1) {
 24 |             if (this.activate(this.getTabByHref(window.location.hash), true)) {
 25 |                 // some tab already activated so do not activate first tab
 26 |                 isActivateFirstTab = false;
 27 |             }
 28 |         }
 29 | 
 30 |         Event.observe(window, "hashchange", function() {
 31 |             var href = window.location.hash;
 32 |             if (href.length <= 1) {
 33 |                 var first = this.container.down(this.config.tabs);
 34 |                 href = first.href || first.readAttribute('data-href');
 35 |             } else {
 36 |                 if (-1 === href.indexOf('#tab_')) {
 37 |                     return;
 38 |                 }
 39 |             }
 40 |             this.deactivate();
 41 |             this.activate(this.getTabByHref(href));
 42 |         }.bind(this));
 43 | 
 44 |         if (isActivateFirstTab) {
 45 |             var first = this.container.down(this.config.tabs);
 46 |             if ('undefined' !== typeof first) {
 47 |                 this.activate(this.getTabByHref(first.href || first.readAttribute('data-href')));
 48 |             }
 49 |         }
 50 | 
 51 |         this.container.select(this.config.tabs).each(function(el ,i) {
 52 |             el.observe('click', this.onclick.bind(this, el));
 53 |             el.addClassName('easytabs-inited');
 54 | 
 55 |             var id = $(el).getAttribute('data-href');
 56 |             if (!id) {
 57 |                 return;
 58 |             }
 59 |             $$(id + '_contents .pages a').each(function(_el){
 60 |                 if (-1 == _el.href.indexOf("#")
 61 |                     && -1 !== _el.href.indexOf(window.location.host)) {
 62 | 
 63 |                     _el.href = _el.href + id;
 64 |                 }
 65 |             });
 66 |         }.bind(this));
 67 | 
 68 |         var headerHeight = this.getThemeStickyHeaderHeight();
 69 |         if (this.container.hasAttribute('data-sticky-tabs')) {
 70 |             this.config.scrollOffset = -headerHeight;
 71 |             // appply sticky tabs
 72 |             this.stickTabsHeader();
 73 |         } else {
 74 |             this.config.scrollOffset -= headerHeight;
 75 |         }
 76 |     },
 77 | 
 78 |     /**
 79 |      * @param {String} tab      Tab to activate
 80 |      * @param {Boolean} scroll  lag to indicate that page should be scrolled to the tab
 81 |      * @return {String|false}   Activated tab of false if tab wasn't found
 82 |      */
 83 |     activate: function(tab, scroll, animate) {
 84 |         var content = this.getTabContent(tab);
 85 |         if (!content) {
 86 |             return false;
 87 |         }
 88 | 
 89 |         document.fire('easytabs:beforeActivate', {
 90 |             'tab'     : tab,
 91 |             'content' : content,
 92 |             'easytabs': this
 93 |         });
 94 | 
 95 |         if (-1 === this.activeTabs.indexOf(tab)) {
 96 |             this.activeTabs.push(tab);
 97 |         }
 98 | 
 99 |         this.getTabs(tab).each(function(a) {
100 |             a.addClassName('active');
101 |             var parentLi = a.up('li');
102 |             parentLi && parentLi.addClassName('active');
103 |         });
104 |         if (!this.isExpandedLayout()) {
105 |             this.openTab(tab, content);
106 |             if (this.isTabsHeaderSticked()) {
107 |                 this.scrollToTab(tab, content, animate);
108 |             }
109 |         }
110 |         if (scroll) {
111 |             this.scrollToTab(tab, content, animate);
112 |         }
113 | 
114 |         document.fire('easytabs:afterActivate', {
115 |             'tab'     : tab,
116 |             'content' : content,
117 |             'easytabs': this
118 |         });
119 | 
120 |         return tab;
121 |     },
122 | 
123 |     openTab: function (tab, content) {
124 |         this._updateCounter(tab);
125 |         content.addClassName('active');
126 |         content.show();
127 |         if (this.container.hasClassName()) {}
128 |     },
129 | 
130 |     scrollToTab: function (tab, content, animate) {
131 |         Effect.ScrollTo(content, {
132 |             duration: animate ? this.config.scrollSpeed : 0,
133 |             offset: this.config.scrollOffset
134 |         });
135 |     },
136 | 
137 |     /**
138 |      * @param {String} tab      Tab to deactivate
139 |      * @return {String|false}   Last deactivated tab or false if tab not found
140 |      */
141 |     deactivate: function(tab) {
142 |         if (!tab) {
143 |             while (this.activeTabs.length) {
144 |                 this.deactivate(this.activeTabs[0]);
145 |             }
146 |             return tab;
147 |         }
148 | 
149 |         var index = this.activeTabs.indexOf(tab);
150 |         if (index > -1) {
151 |             this.activeTabs.splice(index, 1);
152 |         }
153 | 
154 |         var content = this.getTabContent(tab);
155 |         if (!content) {
156 |             return false;
157 |         }
158 | 
159 |         document.fire('easytabs:beforeDeactivate', {
160 |             'tab'     : tab,
161 |             'content' : content,
162 |             'easytabs': this
163 |         });
164 | 
165 |         if (!this.isExpandedLayout()) {
166 |             content.removeClassName('active');
167 |             content.hide();
168 |         }
169 | 
170 |         this.getTabs(tab).each(function(a) {
171 |             a.removeClassName('active');
172 |             var parentLi = a.up('li');
173 |             parentLi && parentLi.removeClassName('active');
174 |         });
175 | 
176 |         document.fire('easytabs:afterDeactivate', {
177 |             'tab'     : tab,
178 |             'content' : content,
179 |             'easytabs': this
180 |         });
181 | 
182 |         return tab;
183 |     },
184 | 
185 |     /**
186 |      * @param {Object} el       Element
187 |      * @param {Object} e        Event
188 |      * @param {String} tab      Tab to activate
189 |      * @param {Boolean} scroll  Flag to indicate that page should be scrolled to the tab
190 |      */
191 |     onclick: function(el, e, tab, scroll, animate) {
192 |         var isAccordion = false,
193 |             accordionTrigger = this.container.down('.easytabs-a-accordion');
194 |         if (accordionTrigger) {
195 |             // accordion tabs are hidden for desktop
196 |             isAccordion = (accordionTrigger.getStyle('display') !== 'none');
197 |         }
198 | 
199 |         tab    = tab || this.getTabByHref(el.href || el.readAttribute('data-href'));
200 |         scroll = scroll || el.hasClassName('easytabs-scroll');
201 |         animate = animate || el.hasClassName('easytabs-animate');
202 | 
203 |         if (isAccordion) {
204 |             if (el.hasClassName('active')) {
205 |                 this.deactivate(tab);
206 |             } else {
207 |                 this.activate(tab, scroll, animate);
208 |             }
209 |         } else {
210 |             this.deactivate();
211 |             this.activate(tab, scroll, animate);
212 |         }
213 |     },
214 | 
215 |     /**
216 |      * Retrieve tab name from the url
217 |      *
218 |      * @param {String} href
219 |      */
220 |     getTabByHref: function(href) {
221 |         var tab = href.match(this.tpl.href + '$');
222 |         if (!tab) {
223 |             return false;
224 |         }
225 |         return tab[1];
226 |     },
227 | 
228 |     /**
229 |      * Update activation counter
230 |      *
231 |      * @param  {String} tab
232 |      * @return void
233 |      */
234 |     _updateCounter: function(tab) {
235 |         if (!this.counters[tab]) {
236 |             this.counters[tab] = 0;
237 |         }
238 |         this.counters[tab]++;
239 |     },
240 | 
241 |     /**
242 |      * Retreive activation count for specified tab
243 |      *
244 |      * @param  {String} tab
245 |      * @return {Integer}
246 |      */
247 |     getActivationCount: function(tab) {
248 |         if (!this.counters[tab]) {
249 |             this.counters[tab] = 0;
250 |         }
251 |         return this.counters[tab];
252 |     },
253 | 
254 |     /**
255 |      * Check is tabs with expanded layout
256 |      *
257 |      * @return {Boolean}
258 |      */
259 |     isExpandedLayout: function () {
260 |         return $(this.container).hasClassName('expanded');
261 |     },
262 | 
263 |     /**
264 |      * Check is tabs header sticked at the moment
265 |      *
266 |      * @return {Boolean}
267 |      */
268 |     isTabsHeaderSticked: function () {
269 |         var header = this.container.down('.easytabs-ul-wrapper');
270 |         return header ? header.hasClassName('is_stuck') : false;
271 |     },
272 | 
273 |     /**
274 |      * Stick tabs header
275 |      *
276 |      * @return void
277 |      */
278 |     stickTabsHeader: function () {
279 |         var tabsHeader = this.container.down('.easytabs-ul-wrapper'),
280 |             tabsContent = this.container.down('.easytabs-content-wrapper'),
281 |             stickyOptins = {
282 |                 offset_top: this.getThemeStickyHeaderHeight(),
283 |                 parent: this.container
284 |             };
285 |         // update tabs scroll offset when sticky tabs header enabled
286 |         this.config.scrollOffset -= tabsHeader.getDimensions().height;
287 |         if (this.isExpandedLayout()) {
288 |             // MAGIC FOR EXPANDED LAYOUT
289 |             // hide empty space of ul-wrapper becuase it has 'visibility: hidden'
290 |             tabsHeader.setStyle({'margin-top': -tabsHeader.getDimensions().height + 'px'});
291 |             stickyOptins.offset_top += tabsHeader.getDimensions().height;
292 |         }
293 |         // initialize sticky
294 |         var sticky = new StickInParent(stickyOptins);
295 |         sticky.stick(tabsHeader);
296 |         // listen scroll to activate tab
297 |         if (this.isExpandedLayout()) {
298 |             Event.observe(
299 |                 window,
300 |                 'scroll',
301 |                 this._debounce(this.activateTabAfterScroll.bind(this), 50, false)
302 |             );
303 |         }
304 |     },
305 | 
306 |     /**
307 |      * Find active tab after scrolling
308 |      *
309 |      * @return void
310 |      */
311 |     activateTabAfterScroll: function () {
312 |         var topScrollOffset = document.viewport.getScrollOffsets().top,
313 |             self = this,
314 |             maxNegative = -99999999,
315 |             tabAlias = '';
316 |         this.container.select('.tab-wrapper').each(function (el) {
317 |             var distance = $(el).cumulativeOffset().top - topScrollOffset + self.config.scrollOffset;
318 |             if (distance < 5 && distance >= maxNegative) {
319 |                 tabAlias = $(el).readAttribute('data-tab');
320 |             }
321 |         });
322 |         if (tabAlias) {
323 |             this.deactivate();
324 |             this.activate(tabAlias, false, false);
325 |         }
326 |     },
327 | 
328 |     _debounce: function (func, wait, immediate) {
329 |         var timeout;
330 |         return function() {
331 |             var context = this, args = arguments;
332 |             var later = function() {
333 |                 timeout = null;
334 |                 if (!immediate) func.apply(context, args);
335 |             };
336 |             var callNow = immediate && !timeout;
337 |             clearTimeout(timeout);
338 |             timeout = setTimeout(later, wait);
339 |             if (callNow) func.apply(context, args);
340 |         };
341 |     },
342 | 
343 |     getTabs: function (alias) {
344 |         var href = this.tpl.href.replace(this.tpl.tab, alias);
345 |         return this.container.select(
346 |             this.config.tabs + '[href="' + href + '"]',
347 |             this.config.tabs + '[data-href="' + href + '"]'
348 |         );
349 |     },
350 | 
351 |     getTabContent: function (alias) {
352 |         var tabContentId = this.tpl.content.replace(this.tpl.tab, alias);
353 |         tabContentId = tabContentId.replace(/\./g, '\\.'); // allow id with period
354 |         return this.container.down('#' + tabContentId);
355 |     },
356 | 
357 |     getThemeStickyHeaderHeight: function () {
358 |         var stickyHeaderSelectors = [
359 |                 '.header-container[sticky_kit]', // flat sticky header
360 |                 '.header-content[sticky_kit]', // pure 2 sticky header
361 |                 '.nav-container[sticky_kit]' // luxury sticky header
362 |             ],
363 |             themeStickyHeader = $$(stickyHeaderSelectors.join(',')).first();
364 |         return themeStickyHeader
365 |             ? themeStickyHeader.getHeight()
366 |             : 0;
367 |     }
368 | };
369 | 
370 | document.observe('dom:loaded', function(){
371 |     window.easytabs = [];
372 |     $$('.easytabs-wrapper').each(function (container){
373 |         window.easytabs.push(new EasyTabs(container));
374 |     })
375 |     // initialize custom links
376 |     if (easytabs.length) {
377 |         var linkSelector = easytabs.first().config.tabs;
378 |         $$(linkSelector).each(function (customLink){
379 |             if (customLink.hasClassName('easytabs-inited')) {
380 |                 return;
381 |             };
382 |             customLink.observe('click', function(event) {
383 |                 var element = this;
384 |                 easytabs.each(function (tabs){
385 |                     tab = tabs.getTabByHref(element.readAttribute('href'));
386 |                     if (tab) {
387 |                         tabs.onclick(element);
388 |                         event.stop();
389 |                         throw $break;
390 |                     }
391 |                 });
392 |             });
393 |             customLink.addClassName('easytabs-inited');
394 |         });
395 |     };
396 | });
397 | 


--------------------------------------------------------------------------------
/skin/frontend/base/default/tm/easytabs/js/product.js:
--------------------------------------------------------------------------------
 1 | document.observe('dom:loaded', function(){
 2 | 
 3 |     // listen click on write review link
 4 |     $$('.rating-links a, .no-rating a').each(function(el) {
 5 |         el.observe('click', function(event) {
 6 |             var stopEventFlag = false;
 7 |             easytabs.each(function (tabs){
 8 |                 var reviewForm = tabs.container.down('#review-form');
 9 |                 if (!reviewForm) { return; }
10 |                 var tabContent = reviewForm.up('.easytabs-content');
11 |                 if (!tabContent) { return; }
12 |                 var alias = tabContent.readAttribute('data-tab-alias');
13 |                 stopEventFlag = true;
14 |                 window.location.hash =
15 |                     tabs.tpl.href.replace(tabs.tpl.tab, alias);
16 |                 tabs.onclick(el, event, alias, false);
17 |                 // scroll to form itself so customer could post review right away
18 |                 tabs.scrollToTab(
19 |                     alias,
20 |                     reviewForm.up('.form-add'),
21 |                     true
22 |                 );
23 |             });
24 |             if (stopEventFlag) {
25 |                 event.stop();
26 |             }
27 |         });
28 |     });
29 | 
30 |     // add tag form initialization
31 |     $$('.easytabs-content #addTagForm').each(function (form){
32 |         if (typeof window.submitTagForm === 'undefined') {
33 |             window.addTagFormJs = new VarienForm(form);
34 |             window.submitTagForm = function () {
35 |                 if(addTagFormJs.validator.validate()) {
36 |                     addTagFormJs.form.submit();
37 |                 }
38 |             };
39 |         } else {
40 |             throw $break;
41 |         }
42 |     });
43 | 
44 | });
45 | 


--------------------------------------------------------------------------------
/skin/frontend/base/default/tm/easytabs/js/prototype.sticky-kit.js:
--------------------------------------------------------------------------------
  1 | // Generated by CoffeeScript 1.9.2
  2 | 
  3 | /**
  4 | @license Sticky-kit v1.1.2 | WTFPL | Leaf Corcoran 2015 | http://leafo.net
  5 |  */
  6 | 
  7 | var StickInParent = function(opts) {
  8 |   var doc, elm, enable_bottoming, fn, i, inner_scrolling, len, manual_spacer, offset_top, outer_width, parent_selector, recalc_every, sticky_class;
  9 |   if (opts == null) {
 10 |     opts = {};
 11 |   }
 12 |   sticky_class = opts.sticky_class, inner_scrolling = opts.inner_scrolling, recalc_every = opts.recalc_every, parent_selector = opts.parent, offset_top = opts.offset_top, manual_spacer = opts.spacer, enable_bottoming = opts.bottoming;
 13 |   if (offset_top == null) {
 14 |     offset_top = 0;
 15 |   }
 16 |   if (parent_selector == null) {
 17 |     parent_selector = void 0;
 18 |   }
 19 |   if (inner_scrolling == null) {
 20 |     inner_scrolling = true;
 21 |   }
 22 |   if (sticky_class == null) {
 23 |     sticky_class = "is_stuck";
 24 |   }
 25 |   doc = $(document);
 26 |   if (enable_bottoming == null) {
 27 |     enable_bottoming = true;
 28 |   }
 29 |   outer_width = function(el) {
 30 |     var computed, w;
 31 |     if (window.getComputedStyle) {
 32 |       computed = window.getComputedStyle(el);
 33 |       w = parseFloat(computed.getPropertyValue("width")) + parseFloat(computed.getPropertyValue("margin-left")) + parseFloat(computed.getPropertyValue("margin-right"));
 34 |       if (computed.getPropertyValue("box-sizing") !== "border-box") {
 35 |         w += parseFloat(computed.getPropertyValue("border-left-width")) + parseFloat(computed.getPropertyValue("border-right-width")) + parseFloat(computed.getPropertyValue("padding-left")) + parseFloat(computed.getPropertyValue("padding-right"));
 36 |       }
 37 |       return w;
 38 |     } else {
 39 |       return el.getWidth() +
 40 |         parseInt(el.getStyle("padding-left"), 10) +
 41 |         parseInt(el.getStyle("padding-right"), 10) +
 42 |         parseInt(el.getStyle("margin-left"), 10) +
 43 |         parseInt(el.getStyle("margin-right"), 10);
 44 |     }
 45 |   };
 46 |   fn = function(elm, padding_bottom, parent_top, parent_height, top, height, el_float, detached) {
 47 |     var bottomed, detach, fixed, last_pos, last_scroll_height, offset, parent, recalc, recalc_and_tick, recalc_counter, spacer, tick;
 48 |     if (elm.readAttribute("sticky_kit")) {
 49 |       return;
 50 |     }
 51 |     elm.writeAttribute("sticky_kit", true);
 52 |     last_scroll_height = document.body.getHeight();
 53 |     parent = elm.up();
 54 |     if (parent_selector != null) {
 55 |       parent = parent_selector;
 56 |     }
 57 |     if (!parent) {
 58 |       throw "failed to find stick parent";
 59 |     }
 60 |     fixed = false;
 61 |     bottomed = false;
 62 |     spacer = manual_spacer != null ? manual_spacer && elm.closest(manual_spacer) : new Element("div");
 63 |     if (spacer) {
 64 |       spacer.setStyle('position', elm.getStyle('position'));
 65 |     }
 66 |     recalc = function() {
 67 |       var border_top, padding_top, restore;
 68 |       if (detached) {
 69 |         return;
 70 |       }
 71 |       last_scroll_height = document.body.getHeight();
 72 |       border_top = parseInt(parent.getStyle("border-top-width"), 10);
 73 |       border_top = isNaN(border_top) ? 0 : border_top; // IE10 returns 'medium'
 74 |       padding_top = parseInt(parent.getStyle("padding-top"), 10);
 75 |       padding_bottom = parseInt(parent.getStyle("padding-bottom"), 10);
 76 |       parent_top = parent.cumulativeOffset().top + border_top + padding_top;
 77 |       parent_height = parent.getHeight();
 78 |       if (fixed) {
 79 |         var tmp = recalc_counter;
 80 |         recalc_counter = null;
 81 |         tick(); // TM fix: prevent removeClassName without unstick event, when recalc_every is used
 82 |         recalc_counter = tmp;
 83 |         if (fixed) {
 84 |           fixed = false;
 85 |           bottomed = false;
 86 |           if (manual_spacer == null) {
 87 |             spacer.insert({
 88 |               after: elm
 89 |             });
 90 |             spacer.remove();
 91 |           }
 92 |           elm.setStyle({
 93 |             position: "",
 94 |             top: "",
 95 |             width: "",
 96 |             bottom: ""
 97 |           }).removeClassName(sticky_class);
 98 |           restore = true;
 99 |         }
100 |       }
101 |       top = elm.cumulativeOffset().top - (parseInt(elm.getStyle("margin-top"), 10) || 0) - offset_top;
102 |       height = elm.getDimensions().height + parseInt(elm.getStyle("margin-top"), 10) + parseInt(elm.getStyle("margin-bottom"), 10);
103 |       el_float = elm.getStyle("float");
104 |       if (spacer) {
105 |         spacer.setStyle({
106 |           width: outer_width(elm) + 'px',
107 |           height: height + 'px',
108 |           display: elm.getStyle("display"),
109 |           "vertical-align": elm.getStyle("vertical-align"),
110 |           "float": el_float
111 |         });
112 |       }
113 |       if (restore) {
114 |         return tick();
115 |       }
116 |     };
117 |     recalc();
118 |     // if (height === parent_height) {
119 |     //   return;
120 |     // }
121 |     last_pos = void 0;
122 |     offset = offset_top;
123 |     recalc_counter = recalc_every;
124 |     tick = function() {
125 |       var css, delta, recalced, scroll, will_bottom, win_height;
126 |       if (detached) {
127 |         return;
128 |       }
129 |       recalced = false;
130 |       if (recalc_counter != null) {
131 |         recalc_counter -= 1;
132 |         if (recalc_counter <= 0) {
133 |           recalc_counter = recalc_every;
134 |           recalc();
135 |           recalced = true;
136 |         }
137 |       }
138 |       if (!recalced && document.body.getHeight() !== last_scroll_height) {
139 |         recalc();
140 |         recalced = true;
141 |       }
142 |       scroll = document.viewport.getScrollOffsets().top;
143 |       if (last_pos != null) {
144 |         delta = scroll - last_pos;
145 |       }
146 |       last_pos = scroll;
147 |       if (fixed) {
148 |         if (enable_bottoming) {
149 |           will_bottom = scroll + height + offset > parent_height + parent_top;
150 |           if (bottomed && !will_bottom) {
151 |             bottomed = false;
152 |             elm.setStyle({
153 |               position: "fixed",
154 |               bottom: "auto",
155 |               top: offset + 'px'
156 |             }).fire("sticky_kit:unbottom");
157 |           }
158 |         }
159 |         if (scroll < top) {
160 |           fixed = false;
161 |           offset = offset_top;
162 |           if (manual_spacer == null) {
163 |             if (el_float === "left" || el_float === "right") {
164 |               spacer.insert({
165 |                 after: elm
166 |               });
167 |             }
168 |             spacer.remove();
169 |           }
170 |           css = {
171 |             position: "",
172 |             width: "",
173 |             top: ""
174 |           };
175 |           elm.setStyle(css).removeClassName(sticky_class).fire("sticky_kit:unstick");
176 |         }
177 |         if (inner_scrolling) {
178 |           win_height = document.viewport.getHeight();
179 |           if (height + offset_top > win_height) {
180 |             if (!bottomed) {
181 |               offset -= delta;
182 |               offset = Math.max(win_height - height, offset);
183 |               offset = Math.min(offset_top, offset);
184 |               if (fixed) {
185 |                 elm.setStyle({
186 |                   top: offset + "px"
187 |                 });
188 |               }
189 |             }
190 |           }
191 |         }
192 |       } else {
193 |         if (scroll > top) {
194 |           fixed = true;
195 |           css = {
196 |             position: "fixed",
197 |             top: offset + 'px'
198 |           };
199 |           css.width = elm.getStyle("box-sizing") === "border-box" ?
200 |             elm.getWidth() + parseInt(elm.getStyle("padding-left"), 10) + parseInt(elm.getStyle("padding-right"), 10) + "px" :
201 |             elm.getWidth() - parseInt(elm.getStyle("border-left-width"), 10) - parseInt(elm.getStyle("border-right-width"), 10) + "px";
202 |           elm.setStyle(css).addClassName(sticky_class);
203 |           if (manual_spacer == null) {
204 |             elm.insert({
205 |               after: spacer
206 |             });
207 |             if (el_float === "left" || el_float === "right") {
208 |               spacer.insert({
209 |                 bottom: elm
210 |               });
211 |             }
212 |           }
213 |           elm.fire("sticky_kit:stick");
214 |         }
215 |       }
216 |       if (fixed && enable_bottoming) {
217 |         if (will_bottom == null) {
218 |           will_bottom = scroll + height + offset > parent_height + parent_top;
219 |         }
220 |         if (!bottomed && will_bottom) {
221 |           bottomed = true;
222 |           if (parent.getStyle("position") === "static") {
223 |             parent.setStyle({
224 |               position: "relative"
225 |             });
226 |           }
227 |           return elm.setStyle({
228 |             position: "absolute",
229 |             bottom: padding_bottom + 'px',
230 |             top: "auto"
231 |           }).fire("sticky_kit:bottom");
232 |         }
233 |       }
234 |     };
235 |     recalc_and_tick = function() {
236 |       recalc();
237 |       return tick();
238 |     };
239 |     detach = function() {
240 |       detached = true;
241 |       document.stopObserving("touchmove", tick);
242 |       document.stopObserving("scroll", tick);
243 |       document.stopObserving("resize", recalc_and_tick);
244 |       $(document.body).stopObserving("sticky_kit:recalc", recalc_and_tick);
245 |       elm.stopObserving("sticky_kit:detach", detach);
246 |       elm.writeAttribute("sticky_kit", false);
247 |       elm.setStyle({
248 |         position: "",
249 |         bottom: "",
250 |         top: "",
251 |         width: ""
252 |       });
253 |       parent.setStyle("position", "");
254 |       if (fixed) {
255 |         if (manual_spacer == null) {
256 |           if (el_float === "left" || el_float === "right") {
257 |             spacer.insert({
258 |               after: elm
259 |             });
260 |             // elm.insertAfter(spacer);
261 |           }
262 |           spacer.remove();
263 |         }
264 |         return elm.removeClassName(sticky_class);
265 |       }
266 |     };
267 |     document.observe("touchmove", tick);
268 |     document.observe("scroll", tick);
269 |     document.observe("resize", recalc_and_tick);
270 |     $(document.body).observe("sticky_kit:recalc", recalc_and_tick);
271 |     elm.observe("sticky_kit:detach", detach);
272 |     return setTimeout(tick, 0);
273 |   };
274 |   return {
275 |     stick: function(el) {
276 |       fn(el);
277 |     }
278 |   };
279 | };
280 | 


--------------------------------------------------------------------------------