├── Elements.php
├── InputWidget.php
├── LICENSE
├── Widget.php
├── assets
    ├── SemanticUICSSAsset.php
    └── SemanticUIJSAsset.php
├── collections
    ├── Breadcrumb.php
    ├── Menu.php
    └── Message.php
├── composer.json
├── helpers
    ├── Color.php
    └── Size.php
├── modules
    ├── Accordion.php
    ├── Checkbox.php
    ├── CheckboxList.php
    ├── Dropdown.php
    ├── Embed.php
    ├── Modal.php
    ├── Progress.php
    ├── Radio.php
    ├── RadioList.php
    ├── Rating.php
    ├── Search.php
    ├── Select.php
    ├── Shape.php
    ├── Sidebar.php
    ├── Sticky.php
    └── Tab.php
├── readme.md
└── widgets
    ├── ActionColumn.php
    ├── ActiveField.php
    ├── ActiveForm.php
    ├── CheckboxColumn.php
    ├── DataColumn.php
    ├── DetailView.php
    ├── GridView.php
    ├── LinkPager.php
    └── Pjax.php


/Elements.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI;
  4 | 
  5 | use yii\helpers\ArrayHelper;
  6 | use yii\helpers\Html;
  7 | 
  8 | class Elements
  9 | {
 10 |     /**
 11 |      * @param string $content
 12 |      * @param array $options
 13 |      *
 14 |      * @return string
 15 |      */
 16 |     public static function button($content, $options = [])
 17 |     {
 18 |         return static::renderElement('button', $content, $options);
 19 |     }
 20 | 
 21 |     /**
 22 |      * @param string $content
 23 |      * @param array $options
 24 |      *
 25 |      * @return string
 26 |      */
 27 |     public static function buttonsGroup($content, $options = [])
 28 |     {
 29 |         return static::renderElement('buttons', $content, $options);
 30 |     }
 31 | 
 32 |     /**
 33 |      * @param string $content
 34 |      * @param array $options
 35 |      *
 36 |      * @return string
 37 |      */
 38 |     public static function divider($content = '', $options = [])
 39 |     {
 40 |         return static::renderElement('divider', $content, $options);
 41 |     }
 42 | 
 43 |     /**
 44 |      * @param string $flag
 45 |      * @param array $options
 46 |      * @return string
 47 |      */
 48 |     public static function flag($flag, $options = [])
 49 |     {
 50 |         Html::addCssClass($options, $flag . ' flag');
 51 |         return Html::tag(ArrayHelper::remove($options, 'tag', 'i'), '', $options);
 52 |     }
 53 | 
 54 |     /**
 55 |      * @param string $icon
 56 |      * @param array $options
 57 |      *
 58 |      * @return string
 59 |      */
 60 |     public static function icon($icon, $options = [])
 61 |     {
 62 |         Html::addCssClass($options, $icon . ' icon');
 63 |         return Html::tag(ArrayHelper::remove($options, 'tag', 'i'), '', $options);
 64 |     }
 65 | 
 66 |     /**
 67 |      * @param string $content
 68 |      * @param array $options
 69 |      *
 70 |      * @return string
 71 |      */
 72 |     public static function header($content, $options = [])
 73 |     {
 74 |         return static::renderElement('header', $content, $options);
 75 |     }
 76 | 
 77 |     /**
 78 |      * @param string $src
 79 |      * @param array $options
 80 |      *
 81 |      * @return string
 82 |      */
 83 |     public static function image($src, $options = [])
 84 |     {
 85 |         Html::addCssClass($options, 'ui ' . ArrayHelper::remove($options, 'class') . ' image');
 86 |         return Html::img($src, $options);
 87 |     }
 88 | 
 89 |     /**
 90 |      * @param string $content
 91 |      * @param array $options
 92 |      *
 93 |      * @return string
 94 |      */
 95 |     public static function imagesGroup($content, $options = [])
 96 |     {
 97 |         return static::renderElement('images', $content, $options);
 98 |     }
 99 | 
100 |     /**
101 |      * @param string $content
102 |      * @param array $options
103 |      *
104 |      * @return string
105 |      */
106 |     public static function input($content, $options = [])
107 |     {
108 |         return static::renderElement('input', $content, $options);
109 |     }
110 | 
111 |     /**
112 |      * @param string $content
113 |      * @param array $options
114 |      *
115 |      * @return string
116 |      */
117 |     public static function label($content, $options = [])
118 |     {
119 |         return static::renderElement('label', $content, $options);
120 |     }
121 | 
122 |     /**
123 |      * @param string $content
124 |      * @param array $options
125 |      *
126 |      * @return string
127 |      */
128 |     public static function labelsGroup($content, $options = [])
129 |     {
130 |         return static::renderElement('labels', $content, $options);
131 |     }
132 | 
133 |     /**
134 |      * @param string $content
135 |      * @param array $options
136 |      *
137 |      * @return string
138 |      */
139 |     public static function listWrapper($content, $options = [])
140 |     {
141 |         return static::renderElement('list', $content, $options);
142 |     }
143 | 
144 |     /**
145 |      * @param string $content
146 |      * @param array $options
147 |      *
148 |      * @return string
149 |      */
150 |     public static function listItem($content, $options = [])
151 |     {
152 |         return static::renderElement('item', $content, $options);
153 |     }
154 | 
155 |     /**
156 |      * @param string $content
157 |      * @param array $options
158 |      *
159 |      * @return string
160 |      */
161 |     public static function dimmer($content, $options = [])
162 |     {
163 |         return static::renderElement('dimmer', $content, $options);
164 |     }
165 | 
166 |     /**
167 |      * @param string $content
168 |      * @param array $options
169 |      *
170 |      * @return string
171 |      */
172 |     public static function loader($content = '', $options = [])
173 |     {
174 |         return static::renderElement('loader', $content, $options);
175 |     }
176 | 
177 |     /**
178 |      * @param string $content
179 |      * @param array $options
180 |      *
181 |      * @return string
182 |      */
183 |     public static function rail($content, $options = [])
184 |     {
185 |         return static::renderElement('rail', $content, $options);
186 |     }
187 | 
188 |     /**
189 |      * @param string $content
190 |      * @param array $options
191 |      *
192 |      * @return string
193 |      */
194 |     public static function reveal($content, $options = [])
195 |     {
196 |         return static::renderElement('reveal', $content, $options);
197 |     }
198 | 
199 |     /**
200 |      * @param string $content
201 |      * @param array $options
202 |      *
203 |      * @return string
204 |      */
205 |     public static function segments($content, $options = [])
206 |     {
207 |         return static::renderElement('segments', $content, $options);
208 |     }
209 | 
210 |     /**
211 |      * @param string $content
212 |      * @param array $options
213 |      *
214 |      * @return string
215 |      */
216 |     public static function segment($content, $options = [])
217 |     {
218 |         return static::renderElement('segment', $content, $options);
219 |     }
220 | 
221 |     /**
222 |      * @param string $content
223 |      * @param array $options
224 |      *
225 |      * @return string
226 |      */
227 |     public static function steps($content, $options = [])
228 |     {
229 |         return static::renderElement('steps', $content, $options);
230 |     }
231 | 
232 |     /**
233 |      * @param string $content
234 |      * @param array $options
235 |      *
236 |      * @return string
237 |      */
238 |     public static function step($content, $options = [])
239 |     {
240 |         return static::renderElement('step', $content, $options);
241 |     }
242 | 
243 |     /**
244 |      * @param string $type
245 |      * @param string $content
246 |      * @param array $options
247 |      *
248 |      * @return string
249 |      */
250 |     public static function renderElement($type, $content, $options = [])
251 |     {
252 |         $tag = ArrayHelper::remove($options, 'tag', 'div');
253 | 
254 |         $class = ArrayHelper::remove($options, 'class');
255 |         Html::addCssClass($options, 'ui ' . $class . ' ' . $type);
256 | 
257 |         return Html::tag($tag, $content, $options);
258 |     }
259 | }
260 | 


--------------------------------------------------------------------------------
/InputWidget.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI;
 4 | 
 5 | use Zelenin\yii\SemanticUI\assets\SemanticUIJSAsset;
 6 | 
 7 | class InputWidget extends \yii\widgets\InputWidget
 8 | {
 9 |     /**
10 |      * @var array
11 |      */
12 |     public $options = [];
13 | 
14 |     /**
15 |      * @var array
16 |      */
17 |     public $clientOptions = [];
18 | 
19 |     public function init()
20 |     {
21 |         parent::init();
22 |         isset($this->options['id'])
23 |             ? $this->setId($this->options['id'])
24 |             : $this->options['id'] = $this->getId();
25 |     }
26 | 
27 |     public function registerJsAsset()
28 |     {
29 |         SemanticUIJSAsset::register($this->getView());
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Aleksandr Zelenin
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/Widget.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI;
 4 | 
 5 | use Zelenin\yii\SemanticUI\assets\SemanticUIJSAsset;
 6 | 
 7 | class Widget extends \yii\base\Widget
 8 | {
 9 |     /**
10 |      * @var array
11 |      */
12 |     public $options = [];
13 | 
14 |     /**
15 |      * @var array
16 |      */
17 |     public $clientOptions = [];
18 | 
19 |     public function init()
20 |     {
21 |         parent::init();
22 |         isset($this->options['id'])
23 |             ? $this->setId($this->options['id'])
24 |             : $this->options['id'] = $this->getId();
25 |     }
26 | 
27 |     public function registerJsAsset()
28 |     {
29 |         SemanticUIJSAsset::register($this->getView());
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/assets/SemanticUICSSAsset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\assets;
 4 | 
 5 | use Yii;
 6 | use yii\web\AssetBundle;
 7 | 
 8 | class SemanticUICSSAsset extends AssetBundle
 9 | {
10 |     /**
11 |      * @var string
12 |      */
13 |     public $sourcePath = '@bower/semantic-ui/dist';
14 | 
15 |     public function init()
16 |     {
17 |         $postfix = YII_DEBUG ? '' : '.min';
18 |         $this->css[] = 'semantic' . $postfix . '.css';
19 | 
20 |         parent::init();
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/assets/SemanticUIJSAsset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\assets;
 4 | 
 5 | use Yii;
 6 | use yii\web\AssetBundle;
 7 | 
 8 | class SemanticUIJSAsset extends AssetBundle
 9 | {
10 |     /**
11 |      * @var string
12 |      */
13 |     public $sourcePath = '@bower/semantic-ui/dist';
14 | 
15 |     /**
16 |      * @var array
17 |      */
18 |     public $depends = [
19 |         'yii\web\JqueryAsset',
20 |         'Zelenin\yii\SemanticUI\assets\SemanticUICSSAsset'
21 |     ];
22 | 
23 |     public function init()
24 |     {
25 |         $postfix = YII_DEBUG ? '' : '.min';
26 |         $this->js[] = 'semantic' . $postfix . '.js';
27 | 
28 |         parent::init();
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/collections/Breadcrumb.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\collections;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\ArrayHelper;
  7 | use yii\helpers\Html;
  8 | use Zelenin\yii\SemanticUI\Widget;
  9 | 
 10 | class Breadcrumb extends Widget
 11 | {
 12 |     /**
 13 |      * @var array
 14 |      */
 15 |     public $links = [];
 16 | 
 17 |     /**
 18 |      * @var array|null|false
 19 |      */
 20 |     public $homeLink;
 21 | 
 22 |     /**
 23 |      * @var array
 24 |      */
 25 |     public $itemOptions = [];
 26 | 
 27 |     /**
 28 |      * @var bool
 29 |      */
 30 |     public $encodeLabels = true;
 31 | 
 32 |     /**
 33 |      * @var string
 34 |      */
 35 |     public $divider = self::DIVIDER_NORMAL;
 36 |     const DIVIDER_NORMAL = ' <div class="divider"> / </div> ';
 37 |     const DIVIDER_CHEVRON = ' <i class="right chevron icon divider"></i> ';
 38 | 
 39 |     /**
 40 |      * @var string
 41 |      */
 42 |     public $size;
 43 | 
 44 |     public function run()
 45 |     {
 46 |         Html::addCssClass($this->options, 'ui breadcrumb');
 47 |         if ($this->size) {
 48 |             Html::addCssClass($this->options, $this->size);
 49 |         }
 50 | 
 51 |         echo Html::tag('div', $this->renderItems(), $this->options);
 52 |     }
 53 | 
 54 |     /**
 55 |      * @return string
 56 |      */
 57 |     public function renderItems()
 58 |     {
 59 |         $items = [];
 60 |         if ($homelink = $this->getHomeLink()) {
 61 |             $items[] = $homelink;
 62 |         }
 63 | 
 64 |         foreach ($this->links as $item) {
 65 |             if (!is_array($item)) {
 66 |                 $item = [
 67 |                     'label' => $item
 68 |                 ];
 69 |             }
 70 |             $items[] = $this->renderItem($item);
 71 |         }
 72 |         return implode($this->divider, $items);
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return bool|string
 77 |      */
 78 |     private function getHomeLink()
 79 |     {
 80 |         if ($this->homeLink === null) {
 81 |             $this->homeLink = [
 82 |                 'label' => Yii::t('yii', 'Home'),
 83 |                 'url' => Yii::$app->getHomeUrl(),
 84 |             ];
 85 |         }
 86 |         return $this->homeLink !== false
 87 |             ? $this->renderItem($this->homeLink)
 88 |             : false;
 89 |     }
 90 | 
 91 |     /**
 92 |      * @param array $item
 93 |      *
 94 |      * @return string
 95 |      */
 96 |     protected function renderItem($item)
 97 |     {
 98 |         $item['label'] = $this->encodeLabels ? Html::encode($item['label']) : $item['label'];
 99 | 
100 |         $options = ArrayHelper::getValue($item, 'options', $this->itemOptions);
101 |         Html::addCssClass($options, 'section');
102 | 
103 |         if (isset($item['url'])) {
104 |             $link = Html::a($item['label'], $item['url'], $options);
105 |         } else {
106 |             Html::addCssClass($options, 'active');
107 |             $link = Html::tag('div', $item['label'], $options);
108 |         }
109 |         return $link;
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/collections/Menu.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\collections;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\ArrayHelper;
  7 | use yii\helpers\Html;
  8 | use yii\helpers\Url;
  9 | use Zelenin\yii\SemanticUI\Elements;
 10 | use Zelenin\yii\SemanticUI\Widget;
 11 | 
 12 | class Menu extends Widget
 13 | {
 14 |     /**
 15 |      * @var string
 16 |      */
 17 |     public $route;
 18 | 
 19 |     /**
 20 |      * @var array
 21 |      */
 22 |     public $params;
 23 | 
 24 |     /**
 25 |      * @var array
 26 |      */
 27 |     public $items = [];
 28 | 
 29 |     /**
 30 |      * @var array
 31 |      */
 32 |     public $rightMenuItems = [];
 33 | 
 34 |     /**
 35 |      * @var array
 36 |      */
 37 |     public $subMenuItems = [];
 38 | 
 39 |     /**
 40 |      * @var array
 41 |      */
 42 |     public $options = [];
 43 | 
 44 |     /**
 45 |      * @var array
 46 |      */
 47 |     public $rightMenuOptions = [];
 48 | 
 49 |     /**
 50 |      * @var array
 51 |      */
 52 |     public $subMenuOptions = [];
 53 | 
 54 |     /**
 55 |      * @var array
 56 |      */
 57 |     public $itemOptions = [];
 58 | 
 59 |     /**
 60 |      * @var bool
 61 |      */
 62 |     public $vertical = false;
 63 |     const TYPE_VERTICAL = 'vertical';
 64 | 
 65 |     /**
 66 |      * @var bool
 67 |      */
 68 |     public $tabular = false;
 69 |     const TYPE_TABULAR = 'tabular';
 70 | 
 71 |     /**
 72 |      * @var bool
 73 |      */
 74 |     public $topAttached = false;
 75 |     const TYPE_TOP_ATTACHED = 'top attached';
 76 | 
 77 |     /**
 78 |      * @var bool
 79 |      */
 80 |     public $tiered = false;
 81 |     const TYPE_TIERED = 'tiered';
 82 | 
 83 |     /**
 84 |      * @var bool
 85 |      */
 86 |     public $secondary = false;
 87 |     const TYPE_SECONDARY = 'secondary';
 88 | 
 89 |     /**
 90 |      * @var bool
 91 |      */
 92 |     public $pointing = false;
 93 |     const TYPE_POINTING = 'pointing';
 94 | 
 95 |     /**
 96 |      * @var bool
 97 |      */
 98 |     public $text = false;
 99 |     const TYPE_TEXT = 'text';
100 | 
101 |     /**
102 |      * @var bool
103 |      */
104 |     public $fluid = false;
105 |     const TYPE_FLUID = 'fluid';
106 |     /**
107 |      * @var bool
108 |      */
109 |     public $borderless = false;
110 |     const TYPE_BORDERLESS = 'borderless';
111 | 
112 |     /**
113 |      * @var bool
114 |      */
115 |     public $inverted = false;
116 |     const TYPE_INVERTED = 'inverted';
117 | 
118 |     /**
119 |      * @var string
120 |      */
121 |     public $color;
122 | 
123 |     /**
124 |      * @var string
125 |      */
126 |     public $size;
127 | 
128 |     /**
129 |      * @var bool
130 |      */
131 |     public $encodeLabels = true;
132 | 
133 |     /**
134 |      * @var bool
135 |      */
136 |     public $activateItems = true;
137 | 
138 |     /**
139 |      * @var bool
140 |      */
141 |     public $activateParents = false;
142 | 
143 |     /**
144 |      * @var bool
145 |      */
146 |     public $hideEmptyItems = true;
147 | 
148 |     public function init()
149 |     {
150 |         parent::init();
151 |         if ($this->route === null && Yii::$app->controller !== null) {
152 |             $this->route = Yii::$app->controller->getRoute();
153 |         }
154 |         if ($this->params === null) {
155 |             $this->params = Yii::$app->getRequest()->getQueryParams();
156 |         }
157 |     }
158 | 
159 |     public function run()
160 |     {
161 |         Html::addCssClass($this->options, 'ui menu');
162 |         if ($this->vertical) {
163 |             Html::addCssClass($this->options, self::TYPE_VERTICAL);
164 |         }
165 |         if ($this->tabular) {
166 |             Html::addCssClass($this->options, self::TYPE_TABULAR);
167 |         }
168 |         if ($this->topAttached) {
169 |             Html::addCssClass($this->options, self::TYPE_TOP_ATTACHED);
170 |         }
171 |         if ($this->tiered) {
172 |             Html::addCssClass($this->options, self::TYPE_TIERED);
173 |         }
174 |         if ($this->secondary) {
175 |             Html::addCssClass($this->options, self::TYPE_SECONDARY);
176 |         }
177 |         if ($this->pointing) {
178 |             Html::addCssClass($this->options, self::TYPE_POINTING);
179 |         }
180 |         if ($this->text) {
181 |             Html::addCssClass($this->options, self::TYPE_TEXT);
182 |         }
183 |         if ($this->fluid) {
184 |             Html::addCssClass($this->options, self::TYPE_FLUID);
185 |         }
186 |         if ($this->inverted) {
187 |             Html::addCssClass($this->options, self::TYPE_INVERTED);
188 |         }
189 |         if ($this->color) {
190 |             Html::addCssClass($this->options, $this->color);
191 |         }
192 |         if ($this->size) {
193 |             Html::addCssClass($this->options, $this->size);
194 |         }
195 |         if ($this->borderless) {
196 |             Html::addCssClass($this->options, self::TYPE_BORDERLESS);
197 |         }
198 | 
199 |         $tag = ArrayHelper::remove($this->options, 'tag', 'div');
200 |         echo Html::tag($tag, $this->renderItems(), $this->options);
201 |     }
202 | 
203 |     /**
204 |      * @return string
205 |      */
206 |     public function renderItems()
207 |     {
208 |         Html::addCssClass($this->rightMenuOptions, 'right menu');
209 |         Html::addCssClass($this->subMenuOptions, 'ui sub menu');
210 | 
211 |         $leftMenuPart = $this->items ? $this->renderMenuPart($this->items) : '';
212 |         $rightMenuPart = $this->rightMenuItems ? Html::tag('div', $this->renderMenuPart($this->rightMenuItems), $this->rightMenuOptions) : '';
213 |         return
214 |             (
215 |             $this->tiered
216 |                 ?
217 |                 Html::tag('div', $leftMenuPart . $rightMenuPart, ['class' => 'menu'])
218 |                 : $leftMenuPart . $rightMenuPart
219 |             ) .
220 |             ($this->subMenuItems ? Html::tag('div', $this->renderMenuPart($this->subMenuItems), $this->subMenuOptions) : '');
221 |     }
222 | 
223 |     /**
224 |      * @param $items
225 |      *
226 |      * @return string
227 |      */
228 |     public function renderMenuPart($items)
229 |     {
230 |         $items = $this->normalizeItems($items, $hasActiveChild);
231 | 
232 |         $lines = '';
233 |         foreach ($items as $i => $item) {
234 |             Html::addCssClass($item['options'], 'item');
235 |             if ($item['active']) {
236 |                 Html::addCssClass($item['options'], 'active');
237 |             }
238 | 
239 |             if (isset($item['items'])) {
240 |                 Html::addCssClass($item['options'], 'ui simple dropdown');
241 |                 $item['label'] =
242 |                     $item['label'] .
243 |                     Elements::icon('dropdown') .
244 |                     Html::tag('div', $this->renderMenuPart($item['items']), ['class' => 'menu']);
245 | 
246 |                 $menu = $this->renderItem($item);
247 |             } else {
248 |                 $menu = $this->renderItem($item);
249 |             }
250 |             $lines .= $menu;
251 |         }
252 |         return $lines;
253 |     }
254 | 
255 |     /**
256 |      * @param $item
257 |      *
258 |      * @return string
259 |      */
260 |     public function renderItem($item)
261 |     {
262 |         if (isset($item['header'])) {
263 |             Html::addCssClass($item['options'], 'header');
264 |             return Html::tag('div', $item['header'], $item['options']);
265 |         } else {
266 |             if (isset($item['url'])) {
267 |                 return Html::a($item['label'], Url::to($item['url']), $item['options']);
268 |             } else {
269 |                 return Html::tag('div', $item['label'], $item['options']);
270 |             }
271 |         }
272 |     }
273 | 
274 |     /**
275 |      * @param array $items
276 |      * @param bool $active
277 |      *
278 |      * @return array
279 |      */
280 |     protected function normalizeItems($items, &$active)
281 |     {
282 |         foreach ($items as $i => $item) {
283 | 
284 |             if (!ArrayHelper::getValue($item, 'visible', true)) {
285 |                 unset($items[$i]);
286 |                 continue;
287 |             }
288 | 
289 |             $item['label'] = ArrayHelper::getValue($item, 'label', '');
290 |             $encodeLabel = ArrayHelper::getValue($item, 'encode', $this->encodeLabels);
291 |             $items[$i]['label'] = $encodeLabel ? Html::encode($item['label']) : $item['label'];
292 |             if (isset($items[$i]['header'])) {
293 |                 $items[$i]['header'] = $encodeLabel ? Html::encode($item['header']) : $item['header'];
294 |             }
295 | 
296 |             $hasActiveChild = false;
297 |             if (isset($item['items'])) {
298 |                 $items[$i]['items'] = $this->normalizeItems($item['items'], $hasActiveChild);
299 |                 if (empty($items[$i]['items']) && $this->hideEmptyItems) {
300 |                     unset($items[$i]['items']);
301 |                     if (!isset($item['url'])) {
302 |                         unset($items[$i]);
303 |                         continue;
304 |                     }
305 |                 }
306 |             }
307 | 
308 |             if (!isset($item['active'])) {
309 |                 $items[$i]['active'] = ($this->activateParents && $hasActiveChild) || ($this->activateItems && $this->isItemActive($item));
310 |             } elseif ($item['active']) {
311 |                 $active = true;
312 |             }
313 |             $item['options'] = ArrayHelper::getValue($items, 'options', $this->itemOptions);
314 |         }
315 | 
316 |         return array_values($items);
317 |     }
318 | 
319 |     /**
320 |      * @param array $item
321 |      *
322 |      * @return bool
323 |      */
324 |     protected function isItemActive($item)
325 |     {
326 |         if (isset($item['url']) && is_array($item['url']) && isset($item['url'][0])) {
327 |             $route = $item['url'][0];
328 |             if ($route[0] !== '/' && Yii::$app->controller) {
329 |                 $route = Yii::$app->controller->module->getUniqueId() . '/' . $route;
330 |             }
331 |             if (ltrim($route, '/') !== $this->route) {
332 |                 return false;
333 |             }
334 |             unset($item['url']['#']);
335 | 
336 |             if (count($item['url']) > 1) {
337 |                 foreach (array_splice($item['url'], 1) as $name => $value) {
338 |                     if ($value !== null && (!isset($this->params[$name]) || $this->params[$name] != $value)) {
339 |                         return false;
340 |                     }
341 |                 }
342 |             }
343 |             return true;
344 |         }
345 |         return false;
346 |     }
347 | }
348 | 


--------------------------------------------------------------------------------
/collections/Message.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\collections;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\Html;
  7 | use Zelenin\yii\SemanticUI\Elements;
  8 | use Zelenin\yii\SemanticUI\Widget;
  9 | 
 10 | class Message extends Widget
 11 | {
 12 |     /**
 13 |      * @var bool
 14 |      */
 15 |     public $icon = false;
 16 |     const TYPE_ICON = 'icon';
 17 | 
 18 |     /**
 19 |      * @var bool
 20 |      */
 21 |     public $hidden = false;
 22 |     const TYPE_HIDDEN = 'hidden';
 23 | 
 24 |     /**
 25 |      * @var bool
 26 |      */
 27 |     public $visible = false;
 28 |     const TYPE_VISIBLE = 'visible';
 29 | 
 30 |     /**
 31 |      * @var bool
 32 |      */
 33 |     public $floating = false;
 34 |     const TYPE_FLOATING = 'floating';
 35 | 
 36 |     /**
 37 |      * @var bool
 38 |      */
 39 |     public $compact = false;
 40 |     const TYPE_COMPACT = 'compact';
 41 | 
 42 |     /**
 43 |      * @var bool
 44 |      */
 45 |     public $attached = false;
 46 |     const TYPE_ATTACHED = 'attached';
 47 | 
 48 |     /**
 49 |      * @var string
 50 |      */
 51 |     public $type;
 52 |     const TYPE_WARNING = 'warning';
 53 |     const TYPE_INFO = 'info';
 54 |     const TYPE_POSITIVE = 'positive';
 55 |     const TYPE_SUCCESS = 'success';
 56 |     const TYPE_NEGATIVE = 'negative';
 57 |     const TYPE_ERROR = 'error';
 58 | 
 59 |     /**
 60 |      * @var string
 61 |      */
 62 |     public $size;
 63 | 
 64 |     /**
 65 |      * @var string
 66 |      */
 67 |     public $color;
 68 | 
 69 |     public function init()
 70 |     {
 71 |         parent::init();
 72 | 
 73 |         Html::addCssClass($this->options, 'ui message');
 74 |         if ($this->icon) {
 75 |             Html::addCssClass($this->options, self::TYPE_ICON);
 76 |         }
 77 |         if ($this->hidden) {
 78 |             Html::addCssClass($this->options, self::TYPE_HIDDEN);
 79 |         }
 80 |         if ($this->visible) {
 81 |             Html::addCssClass($this->options, self::TYPE_VISIBLE);
 82 |         }
 83 |         if ($this->floating) {
 84 |             Html::addCssClass($this->options, self::TYPE_FLOATING);
 85 |         }
 86 |         if ($this->compact) {
 87 |             Html::addCssClass($this->options, self::TYPE_COMPACT);
 88 |         }
 89 |         if ($this->attached) {
 90 |             Html::addCssClass($this->options, self::TYPE_ATTACHED);
 91 |         }
 92 |         if ($this->size) {
 93 |             Html::addCssClass($this->options, $this->size);
 94 |         }
 95 |         if ($this->color) {
 96 |             Html::addCssClass($this->options, $this->color);
 97 |         }
 98 |         if ($this->type) {
 99 |             Html::addCssClass($this->options, $this->type);
100 |         }
101 | 
102 |         echo Html::beginTag('div', $this->options);
103 |     }
104 | 
105 |     public function run()
106 |     {
107 |         echo Html::endTag('div');
108 |     }
109 | 
110 |     /**
111 |      * @param array $options
112 |      *
113 |      * @return string
114 |      */
115 |     public function renderCloseButton($options = [])
116 |     {
117 |         if (!isset($options['id'])) {
118 |             $options['id'] = $this->getId() . '-close-button';
119 |         }
120 | 
121 |         $this->getView()->registerJs('
122 |         jQuery("#' . $options['id'] . '").on("click", function(event) {
123 |             jQuery("#' . $this->getId() . '").fadeOut();
124 |         });
125 |         ');
126 | 
127 |         return Elements::icon('close', $options);
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "zelenin/yii2-semantic-ui",
 3 |     "description": "Semantic UI extension for Yii2",
 4 |     "type": "yii2-extension",
 5 |     "keywords": [
 6 |         "yii2",
 7 |         "widgets",
 8 |         "semantic",
 9 |         "semantic ui"
10 |     ],
11 |     "homepage": "https://github.com/zelenin/yii2-semantic-ui",
12 |     "license": "MIT",
13 |     "authors": [
14 |         {
15 |             "name": "Aleksandr Zelenin",
16 |             "email": "aleksandr@zelenin.me",
17 |             "homepage": "http://zelenin.me",
18 |             "role": "Developer"
19 |         }
20 |     ],
21 |     "support": {
22 |         "issues": "https://github.com/zelenin/yii2-semantic-ui/issues",
23 |         "source": "https://github.com/zelenin/yii2-semantic-ui"
24 |     },
25 |     "require": {
26 |         "yiisoft/yii2": "~2",
27 |         "bower-asset/semantic-ui": "~2"
28 |     },
29 |     "autoload": {
30 |         "psr-4": {
31 |             "Zelenin\\yii\\SemanticUI\\": ""
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/helpers/Color.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\helpers;
 4 | 
 5 | class Color
 6 | {
 7 |     const RED = 'red';
 8 |     const ORANGE = 'orange';
 9 |     const YELLOW = 'yellow';
10 |     const OLIVE = 'olive';
11 |     const GREEN = 'green';
12 |     const TEAL = 'teal';
13 |     const BLUE = 'blue';
14 |     const VIOLET = 'violet';
15 |     const PURPLE = 'purple';
16 |     const PINK = 'pink';
17 |     const BROWN = 'brown';
18 |     const GREY = 'grey';
19 |     const BLACK = 'black';
20 | }
21 | 


--------------------------------------------------------------------------------
/helpers/Size.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\helpers;
 4 | 
 5 | class Size
 6 | {
 7 |     const MINI = 'mini';
 8 |     const TINY = 'tiny';
 9 |     const SMALL = 'small';
10 |     const MEDIUM = 'medium';
11 |     const LARGE = 'large';
12 |     const BIG = 'big';
13 |     const HUGE = 'huge';
14 |     const MASSIVE = 'massive';
15 | }
16 | 


--------------------------------------------------------------------------------
/modules/Accordion.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\modules;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\ArrayHelper;
  7 | use yii\helpers\Html;
  8 | use yii\helpers\Json;
  9 | use Zelenin\yii\SemanticUI\Elements;
 10 | use Zelenin\yii\SemanticUI\Widget;
 11 | 
 12 | class Accordion extends Widget
 13 | {
 14 |     /**
 15 |      * @var array
 16 |      */
 17 |     public $items = [];
 18 | 
 19 |     /**
 20 |      * @var array
 21 |      */
 22 |     public $titleOptions = [];
 23 | 
 24 |     /**
 25 |      * @var array
 26 |      */
 27 |     public $contentOptions = [];
 28 | 
 29 |     /**
 30 |      * @var bool
 31 |      */
 32 |     public $styled = false;
 33 |     const TYPE_STYLED = 'styled';
 34 | 
 35 |     /**
 36 |      * @var bool
 37 |      */
 38 |     public $fluid = false;
 39 |     const TYPE_FLUID = 'fluid';
 40 | 
 41 |     /**
 42 |      * @var bool
 43 |      */
 44 |     public $vertical = false;
 45 |     const TYPE_VERTICAL = 'vertical';
 46 | 
 47 |     /**
 48 |      * @var bool
 49 |      */
 50 |     public $inverted = false;
 51 |     const TYPE_INVERTED = 'inverted';
 52 | 
 53 |     public function run()
 54 |     {
 55 |         $this->registerJs();
 56 | 
 57 |         Html::addCssClass($this->options, 'ui accordion');
 58 |         if ($this->styled) {
 59 |             Html::addCssClass($this->options, self::TYPE_STYLED);
 60 |         }
 61 |         if ($this->fluid) {
 62 |             Html::addCssClass($this->options, self::TYPE_FLUID);
 63 |         }
 64 |         if ($this->vertical) {
 65 |             Html::addCssClass($this->options, self::TYPE_VERTICAL);
 66 |         }
 67 |         if ($this->inverted) {
 68 |             Html::addCssClass($this->options, self::TYPE_INVERTED);
 69 |             echo Elements::segment(Html::tag('div', $this->renderItems(), $this->options), ['class' => self::TYPE_INVERTED]);
 70 |         } else {
 71 |             echo Html::tag('div', $this->renderItems(), $this->options);
 72 |         }
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return string
 77 |      */
 78 |     public function renderItems()
 79 |     {
 80 |         $items = '';
 81 |         foreach ($this->items as $item) {
 82 |             $items .= $this->renderItem($this->normalizeItem($item));
 83 |         }
 84 |         return $items;
 85 |     }
 86 | 
 87 |     /**
 88 |      * @param array $item
 89 |      *
 90 |      * @return string
 91 |      */
 92 |     public function renderItem($item)
 93 |     {
 94 |         return $this->renderTitle($item) . $this->renderContent($item);
 95 |     }
 96 | 
 97 |     /**
 98 |      * @param array $item
 99 |      *
100 |      * @return string
101 |      */
102 |     public function renderTitle($item)
103 |     {
104 |         $options = ArrayHelper::merge($this->titleOptions, ArrayHelper::getValue($item, 'titleOptions', []));
105 | 
106 |         $encode = ArrayHelper::getValue($options, 'encode', true);
107 |         $title = Elements::icon('dropdown') . ($encode ? Html::encode($item['title']) : $item['title']);
108 | 
109 |         Html::addCssClass($options, 'title');
110 |         if ($item['active']) {
111 |             Html::addCssClass($options, 'active');
112 |         }
113 |         return Html::tag('div', $title, $options);
114 |     }
115 | 
116 |     /**
117 |      * @param array $item
118 |      *
119 |      * @return string
120 |      */
121 |     public function renderContent($item)
122 |     {
123 |         $options = ArrayHelper::merge($this->contentOptions, ArrayHelper::getValue($item, 'contentOptions', []));
124 | 
125 |         $encode = ArrayHelper::getValue($options, 'encode', true);
126 |         $content = $encode ? Html::encode($item['content']) : $item['content'];
127 | 
128 |         Html::addCssClass($options, 'content');
129 |         if ($item['active']) {
130 |             Html::addCssClass($options, 'active');
131 |         }
132 |         return Html::tag('div', $content, $options);
133 |     }
134 | 
135 |     /**
136 |      * @param array $item
137 |      *
138 |      * @return array
139 |      */
140 |     public function normalizeItem($item)
141 |     {
142 |         $item['active'] = ArrayHelper::remove($item, 'active', false);
143 |         return $item;
144 |     }
145 | 
146 |     public function registerJs()
147 |     {
148 |         $this->registerJsAsset();
149 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
150 |         $this->getView()->registerJs('jQuery("#' . $this->options['id'] . '").accordion(' . $clientOptions . ');');
151 |     }
152 | }
153 | 


--------------------------------------------------------------------------------
/modules/Checkbox.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\modules;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\Html;
  7 | use yii\helpers\Json;
  8 | use Zelenin\yii\SemanticUI\InputWidget;
  9 | 
 10 | class Checkbox extends InputWidget
 11 | {
 12 |     /**
 13 |      * @var string
 14 |      */
 15 |     public $label;
 16 |     /**
 17 |      * @var array
 18 |      */
 19 |     public $labelOptions = [];
 20 | 
 21 |     /**
 22 |      * @var array
 23 |      */
 24 |     public $inputOptions = [];
 25 | 
 26 |     /**
 27 |      * @var bool
 28 |      */
 29 |     public $checked = false;
 30 | 
 31 |     /**
 32 |      * @var string
 33 |      */
 34 |     public $type = self::TYPE_CHECKBOX;
 35 |     const TYPE_CHECKBOX = '';
 36 |     const TYPE_SLIDER = 'slider';
 37 |     const TYPE_TOGGLE = 'toggle';
 38 | 
 39 |     /**
 40 |      * @var bool
 41 |      */
 42 |     public $readOnly = false;
 43 |     const TYPE_READONLY = 'read-only';
 44 | 
 45 |     /**
 46 |      * @var bool
 47 |      */
 48 |     public $disabled = false;
 49 |     const TYPE_DISABLED = 'disabled';
 50 | 
 51 |     /**
 52 |      * @var bool
 53 |      */
 54 |     public $fitted = false;
 55 |     const TYPE_FITTED = 'fitted';
 56 | 
 57 |     public function run()
 58 |     {
 59 |         $this->registerJs();
 60 |         $this->prepareInputId();
 61 | 
 62 |         Html::addCssClass($this->options, 'ui ' . $this->type . ' checkbox');
 63 |         if ($this->readOnly) {
 64 |             Html::addCssClass($this->options, self::TYPE_READONLY);
 65 |         }
 66 |         if ($this->disabled) {
 67 |             Html::addCssClass($this->options, self::TYPE_DISABLED);
 68 |         }
 69 |         if ($this->fitted) {
 70 |             Html::addCssClass($this->options, self::TYPE_FITTED);
 71 |         }
 72 | 
 73 |         echo Html::tag('div', $this->renderInput() . $this->renderLabel(), $this->options);
 74 |     }
 75 | 
 76 |     /**
 77 |      * @return string
 78 |      */
 79 |     public function renderInput()
 80 |     {
 81 |         $this->inputOptions['label'] = null;
 82 |         return $this->hasModel()
 83 |             ? Html::activeCheckbox($this->model, $this->attribute, $this->inputOptions)
 84 |             : Html::checkbox($this->name, $this->checked, $this->inputOptions);
 85 |     }
 86 | 
 87 |     public function prepareInputId()
 88 |     {
 89 |         if (!isset($this->inputOptions['id'])) {
 90 |             $id = $this->getId() . '-' . ($this->hasModel() ? $this->attribute : $this->name);
 91 |             $this->inputOptions['id'] = $id;
 92 |         }
 93 |     }
 94 | 
 95 |     /**
 96 |      * @return string
 97 |      */
 98 |     public function renderLabel()
 99 |     {
100 |         if (!isset($this->labelOptions['for'])) {
101 |             $this->labelOptions['for'] = ($this->hasModel() ? $this->attribute : $this->name);
102 |         }
103 |         return $this->hasModel()
104 |             ? Html::activeLabel($this->model, $this->attribute, $this->labelOptions)
105 |             : Html::label($this->label, $this->labelOptions['for'], $this->labelOptions);
106 |     }
107 | 
108 |     public function registerJs()
109 |     {
110 |         $this->registerJsAsset();
111 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
112 |         $this->getView()->registerJs('jQuery("#' . $this->options['id'] . '").checkbox(' . $clientOptions . ');');
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/modules/CheckboxList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\ArrayHelper;
 7 | use yii\helpers\Html;
 8 | use Zelenin\yii\SemanticUI\InputWidget;
 9 | 
10 | class CheckboxList extends InputWidget
11 | {
12 |     /**
13 |      * @var array
14 |      */
15 |     public $items = [];
16 | 
17 |     /**
18 |      * @var mixed
19 |      */
20 |     public $selection = null;
21 | 
22 |     /**
23 |      * @var array
24 |      */
25 |     public $labelOptions = [];
26 | 
27 |     /**
28 |      * @var array
29 |      */
30 |     public $inputOptions = [];
31 | 
32 |     /**
33 |      * @var array
34 |      */
35 |     public $listOptions = [];
36 | 
37 |     public function run()
38 |     {
39 |         $this->prepareOptions();
40 |         echo $this->renderInput();
41 |     }
42 | 
43 |     /**
44 |      * @return string
45 |      */
46 |     public function renderInput()
47 |     {
48 |         return $this->hasModel()
49 |             ? Html::activeCheckboxList($this->model, $this->attribute, $this->items, $this->options)
50 |             : Html::checkboxList($this->name, $this->selection, $this->items, $this->options);
51 |     }
52 | 
53 |     /**
54 |      * @return callable
55 |      */
56 |     public function getDefaultItem()
57 |     {
58 |         return function ($index, $label, $name, $checked, $value) {
59 |             $inputOptions = $this->inputOptions;
60 |             $inputOptions['value'] = ArrayHelper::getValue($inputOptions, 'value', $value);
61 |             return Html::tag(
62 |                 'div',
63 |                 Checkbox::widget([
64 |                     'name' => $name,
65 |                     'label' => $label,
66 |                     'checked' => $checked,
67 |                     'inputOptions' => $inputOptions,
68 |                     'labelOptions' => $this->labelOptions
69 |                 ]),
70 |                 ['class' => 'field']
71 |             );
72 |         };
73 |     }
74 | 
75 |     public function prepareOptions()
76 |     {
77 |         $defaultItem = $this->getDefaultItem();
78 |         $this->options['item'] = ArrayHelper::getValue($this->options, 'item', $defaultItem);
79 |         $this->options['itemOptions'] = $this->listOptions;
80 |         Html::addCssClass($this->options, 'grouped inline fields');
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/modules/Dropdown.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\modules;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\Html;
  7 | use yii\helpers\Json;
  8 | use yii\web\View;
  9 | use Zelenin\yii\SemanticUI\InputWidget;
 10 | 
 11 | class Dropdown extends InputWidget
 12 | {
 13 |     /**
 14 |      * @var array
 15 |      */
 16 |     public $items = [];
 17 | 
 18 |     /**
 19 |      * @var mixed
 20 |      */
 21 |     public $selection = null;
 22 | 
 23 |     /**
 24 |      * @var string
 25 |      */
 26 |     public $type = self::TYPE_SELECTION;
 27 |     const TYPE_DEFAULT = '';
 28 |     const TYPE_SELECTION = 'selection';
 29 | 
 30 |     /**
 31 |      * @var bool
 32 |      */
 33 |     public $search = false;
 34 |     const TYPE_SEARCH = 'search';
 35 | 
 36 |     /**
 37 |      * @var bool
 38 |      */
 39 |     public $fluid = false;
 40 |     const TYPE_FLUID = 'fluid';
 41 | 
 42 |     /**
 43 |      * @var bool
 44 |      */
 45 |     public $compact = false;
 46 |     const TYPE_COMPACT = 'compact';
 47 | 
 48 |     /**
 49 |      * @var bool
 50 |      */
 51 |     public $disabled = false;
 52 |     const TYPE_DISABLED = 'disabled';
 53 | 
 54 |     /**
 55 |      * @var bool
 56 |      */
 57 |     public $upward = false;
 58 |     const TYPE_UPWARD = 'upward';
 59 | 
 60 |     /**
 61 |      * @var bool
 62 |      */
 63 |     public $multiple = false;
 64 |     const TYPE_MULTIPLE = 'multiple';
 65 | 
 66 |     /**
 67 |      * @var string
 68 |      */
 69 |     public $defaultText;
 70 | 
 71 |     /**
 72 |      * @var string
 73 |      */
 74 |     public $icon = '<i class="dropdown icon"></i>';
 75 | 
 76 |     public function run()
 77 |     {
 78 |         $this->registerJs();
 79 | 
 80 |         Html::addCssClass($this->options, 'ui ' . $this->type . ' dropdown');
 81 | 
 82 |         if ($this->search) {
 83 |             Html::addCssClass($this->options, self::TYPE_SEARCH);
 84 |         }
 85 |         if ($this->fluid) {
 86 |             Html::addCssClass($this->options, self::TYPE_FLUID);
 87 |         }
 88 |         if ($this->disabled) {
 89 |             Html::addCssClass($this->options, self::TYPE_DISABLED);
 90 |         }
 91 |         if ($this->compact) {
 92 |             Html::addCssClass($this->options, self::TYPE_COMPACT);
 93 |         }
 94 |         if ($this->upward) {
 95 |             Html::addCssClass($this->options, self::TYPE_UPWARD);
 96 |         }
 97 |         if ($this->multiple) {
 98 |             Html::addCssClass($this->options, self::TYPE_MULTIPLE);
 99 |         }
100 | 
101 |         echo Html::tag(
102 |             'div',
103 |             $this->renderHiddenInput() . $this->renderText() . $this->renderDropdown(),
104 |             $this->options
105 |         );
106 |     }
107 | 
108 |     /**
109 |      * @return string
110 |      */
111 |     public function renderHiddenInput()
112 |     {
113 |         return $this->hasModel()
114 |             ? Html::activeHiddenInput($this->model, $this->attribute, [])
115 |             : Html::hiddenInput($this->name, $this->selection, []);
116 |     }
117 | 
118 |     /**
119 |      * @return string
120 |      */
121 |     public function renderText()
122 |     {
123 |         return Html::tag('div', $this->defaultText, ['class' => 'default text']);
124 |     }
125 | 
126 |     /**
127 |      * @return string
128 |      */
129 |     public function renderDropdown()
130 |     {
131 |         return
132 |             $this->icon .
133 |             Html::tag('div', $this->renderItems(), ['class' => 'menu']);
134 |     }
135 | 
136 |     /**
137 |      * @return string
138 |      */
139 |     public function renderItems()
140 |     {
141 |         $items = '';
142 |         foreach ($this->items as $key => $item) {
143 |             if (is_array($item)) {
144 |                 $items .= $this->renderHeader($key);
145 |                 $rawItems = $item;
146 |                 foreach ($rawItems as $key => $item) {
147 |                     $items .= $this->renderItem($key, $item);
148 |                 }
149 |             } elseif (empty($item)) {
150 |                 $items .= $this->renderDivider();
151 |             } else {
152 |                 $items .= $this->renderItem($key, $item);
153 |             }
154 |         }
155 |         return $items;
156 |     }
157 | 
158 |     /**
159 |      * @param string $item
160 |      *
161 |      * @return string
162 |      */
163 |     public function renderHeader($item)
164 |     {
165 |         return Html::tag('div', $item, ['class' => 'header']);
166 |     }
167 | 
168 |     /**
169 |      * @return string
170 |      */
171 |     public function renderDivider()
172 |     {
173 |         return Html::tag('div', '', ['class' => 'divider']);
174 |     }
175 | 
176 |     /**
177 |      * @param string $key
178 |      * @param string $item
179 |      *
180 |      * @return string
181 |      */
182 |     public function renderItem($key, $item)
183 |     {
184 |         return Html::tag('div', $item, [
185 |             'data' => ['value' => $key],
186 |             'class' => 'item'
187 |         ]);
188 |     }
189 | 
190 |     public function registerJs()
191 |     {
192 |         $this->registerJsAsset();
193 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
194 |         $this->getView()->registerJs('jQuery("#' . $this->getId() . '").dropdown(' . $clientOptions . ');', View::POS_END);
195 |     }
196 | }
197 | 


--------------------------------------------------------------------------------
/modules/Embed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use yii\helpers\Html;
 6 | use yii\helpers\Json;
 7 | use yii\web\View;
 8 | use Zelenin\yii\SemanticUI\Widget;
 9 | 
10 | class Embed extends Widget
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     public $source;
16 |     const SOURCE_YOUTUBE = 'youtube';
17 |     const SOURCE_VIMEO = 'vimeo';
18 | 
19 |     /**
20 |      * @var string
21 |      */
22 |     public $id;
23 | 
24 |     /**
25 |      * @var string
26 |      */
27 |     public $placeholder;
28 | 
29 |     /**
30 |      * @var string
31 |      */
32 |     public $url;
33 | 
34 |     /**
35 |      * @var string
36 |      */
37 |     public $icon;
38 | 
39 |     public function run()
40 |     {
41 |         $this->registerJs();
42 | 
43 |         Html::addCssClass($this->options, 'ui embed');
44 | 
45 |         $this->options['data']['source'] = $this->source;
46 |         $this->options['data']['id'] = $this->id;
47 | 
48 |         if ($this->placeholder) {
49 |             $this->options['data']['placeholder'] = $this->placeholder;
50 |         }
51 |         if ($this->url) {
52 |             $this->options['data']['url'] = $this->url;
53 |         }
54 |         if ($this->icon) {
55 |             $this->options['data']['icon'] = $this->icon;
56 |         }
57 | 
58 |         echo Html::tag('div', '', $this->options);
59 |     }
60 | 
61 |     public function registerJs()
62 |     {
63 |         $this->registerJsAsset();
64 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
65 |         $this->getView()->registerJs('jQuery("#' . $this->getId() . '").embed(' . $clientOptions . ');', View::POS_END);
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/modules/Modal.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\modules;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\Html;
  7 | use yii\helpers\Json;
  8 | use Zelenin\yii\SemanticUI\Elements;
  9 | use Zelenin\yii\SemanticUI\Widget;
 10 | 
 11 | class Modal extends Widget
 12 | {
 13 |     /**
 14 |      * @var string
 15 |      */
 16 |     public $closeButton = '<i class="close icon"></i>';
 17 | 
 18 |     /**
 19 |      * @var string
 20 |      */
 21 |     public $header;
 22 |     /**
 23 |      * @var array
 24 |      */
 25 |     public $headerOptions = [];
 26 | 
 27 |     /**
 28 |      * @var string
 29 |      */
 30 |     public $content;
 31 |     /**
 32 |      * @var array
 33 |      */
 34 |     public $contentOptions = [];
 35 | 
 36 |     /**
 37 |      * @var string
 38 |      */
 39 |     public $actions;
 40 |     /**
 41 |      * @var array
 42 |      */
 43 |     public $actionsOptions = [];
 44 | 
 45 |     /**
 46 |      * @var string
 47 |      */
 48 |     public $type = self::TYPE_STANDARD;
 49 |     const TYPE_BASIC = 'basic';
 50 |     const TYPE_STANDARD = 'standard';
 51 | 
 52 |     /**
 53 |      * @var bool
 54 |      */
 55 |     public $fullscreen = false;
 56 |     const TYPE_FULLSCREEN = 'fullscreen';
 57 | 
 58 |     /**
 59 |      * @var string
 60 |      */
 61 |     public $size;
 62 | 
 63 |     public function init()
 64 |     {
 65 |         parent::init();
 66 | 
 67 |         $this->registerJs();
 68 | 
 69 |         Html::addCssClass($this->options, 'ui ' . $this->type . ' modal');
 70 |         if ($this->fullscreen) {
 71 |             Html::addCssClass($this->options, self::TYPE_FULLSCREEN);
 72 |         }
 73 |         if ($this->size) {
 74 |             Html::addCssClass($this->options, $this->size);
 75 |         }
 76 | 
 77 |         echo Html::beginTag('div', $this->options);
 78 |         echo $this->renderCloseButton();
 79 |         echo $this->renderHeader();
 80 |         Html::addCssClass($this->contentOptions, 'content');
 81 |         echo Html::beginTag('div', $this->contentOptions);
 82 |     }
 83 | 
 84 |     public function run()
 85 |     {
 86 |         echo Html::endTag('div');
 87 |         echo $this->renderActions();
 88 |         echo Html::endTag('div');
 89 |     }
 90 | 
 91 |     /**
 92 |      * @return string
 93 |      */
 94 |     public function renderCloseButton()
 95 |     {
 96 |         return $this->closeButton;
 97 |     }
 98 | 
 99 |     /**
100 |      * @return null|string
101 |      */
102 |     public function renderHeader()
103 |     {
104 |         Html::addCssClass($this->headerOptions, 'header');
105 |         return $this->header ? Html::tag('div', $this->header, $this->headerOptions) : null;
106 |     }
107 | 
108 |     /**
109 |      * @return null|string
110 |      */
111 |     public function renderActions()
112 |     {
113 |         Html::addCssClass($this->actionsOptions, 'actions');
114 |         return $this->actions ? Html::tag('div', $this->actions, $this->actionsOptions) : null;
115 |     }
116 | 
117 |     /**
118 |      * @param string $content
119 |      * @param array $options
120 |      *
121 |      * @return string
122 |      */
123 |     public function renderToggleButton($content, $options = [])
124 |     {
125 |         if (!isset($options['id'])) {
126 |             $options['id'] = $this->getId() . '-button';
127 |         }
128 | 
129 |         $this->getView()->registerJs('
130 |         jQuery("#' . $options['id'] . '").on("click", function(event) {
131 |             event.preventDefault();
132 |             jQuery("#' . $this->getId() . '").modal("show");
133 |         });
134 |         ');
135 | 
136 |         return Elements::button($content, $options);
137 |     }
138 | 
139 |     public function registerJs()
140 |     {
141 |         $this->registerJsAsset();
142 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
143 |         $this->getView()->registerJs('jQuery("#' . $this->options['id'] . '").modal(' . $clientOptions . ');');
144 |     }
145 | }
146 | 


--------------------------------------------------------------------------------
/modules/Progress.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\modules;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\Html;
  7 | use yii\helpers\Json;
  8 | use Zelenin\yii\SemanticUI\Widget;
  9 | 
 10 | class Progress extends Widget
 11 | {
 12 |     /**
 13 |      * @var string
 14 |      */
 15 |     public $label;
 16 | 
 17 |     /**
 18 |      * @var string
 19 |      */
 20 |     public $progress;
 21 | 
 22 |     /**
 23 |      * @var string
 24 |      */
 25 |     public $state;
 26 |     const STATE_ACTIVE = 'active';
 27 |     const STATE_SUCCESS = 'success';
 28 |     const STATE_WARNING = 'warning';
 29 |     const STATE_ERROR = 'error';
 30 |     const STATE_DISABLED = 'disabled';
 31 | 
 32 |     /**
 33 |      * @var bool
 34 |      */
 35 |     public $inverted = false;
 36 |     const TYPE_INVERTED = 'inverted';
 37 | 
 38 |     /**
 39 |      * @var bool
 40 |      */
 41 |     public $indicating = false;
 42 |     const TYPE_INDICATING = 'indicating';
 43 | 
 44 |     /**
 45 |      * @var string
 46 |      */
 47 |     public $attached;
 48 |     const ATTACHED_TOP = 'top attached';
 49 |     const ATTACHED_BOTTOM = 'bottom attached';
 50 | 
 51 |     /**
 52 |      * @var string
 53 |      */
 54 |     public $size;
 55 | 
 56 |     /**
 57 |      * @var string
 58 |      */
 59 |     public $color;
 60 | 
 61 |     public function run()
 62 |     {
 63 |         $this->registerJs();
 64 | 
 65 |         Html::addCssClass($this->options, 'ui progress');
 66 | 
 67 |         if ($this->indicating) {
 68 |             Html::addCssClass($this->options, self::TYPE_INDICATING);
 69 |         }
 70 |         if ($this->inverted) {
 71 |             Html::addCssClass($this->options, self::TYPE_INVERTED);
 72 |         }
 73 |         if ($this->attached) {
 74 |             Html::addCssClass($this->options, $this->attached);
 75 |         }
 76 |         if ($this->size) {
 77 |             Html::addCssClass($this->options, $this->size);
 78 |         }
 79 |         if ($this->state) {
 80 |             Html::addCssClass($this->options, $this->state);
 81 |         }
 82 |         if ($this->color) {
 83 |             Html::addCssClass($this->options, $this->color);
 84 |         }
 85 | 
 86 |         echo Html::tag('div', $this->renderBar() . $this->renderLabel(), $this->options);
 87 |     }
 88 | 
 89 |     /**
 90 |      * @return string
 91 |      */
 92 |     public function renderBar()
 93 |     {
 94 |         return Html::tag('div', $this->renderProgress(), ['class' => 'bar']);;
 95 |     }
 96 | 
 97 |     /**
 98 |      * @return string
 99 |      */
100 |     public function renderLabel()
101 |     {
102 |         if ($this->label) {
103 |             return Html::tag('div', $this->label, ['class' => 'label']);
104 |         } else {
105 |             return '';
106 |         }
107 |     }
108 | 
109 |     /**
110 |      * @return string
111 |      */
112 |     public function renderProgress()
113 |     {
114 |         if ($this->progress) {
115 |             return Html::tag('div', $this->progress, ['class' => 'progress']);
116 |         } else {
117 |             return '';
118 |         }
119 |     }
120 | 
121 |     public function registerJs()
122 |     {
123 |         $this->registerJsAsset();
124 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
125 |         $this->getView()->registerJs('jQuery("#' . $this->options['id'] . '").progress(' . $clientOptions . ');');
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/modules/Radio.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\Html;
 7 | 
 8 | class Radio extends Checkbox
 9 | {
10 |     /**
11 |      * @var string
12 |      */
13 |     public $type = self::TYPE_RADIO;
14 |     const TYPE_RADIO = 'radio';
15 | 
16 |     public function renderInput()
17 |     {
18 |         return $this->hasModel()
19 |             ? Html::activeRadio($this->model, $this->attribute, $this->inputOptions)
20 |             : Html::radio($this->name, $this->checked, $this->inputOptions);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/modules/RadioList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\ArrayHelper;
 7 | use yii\helpers\Html;
 8 | 
 9 | class RadioList extends CheckboxList
10 | {
11 |     /**
12 |      * @return string
13 |      */
14 |     public function renderInput()
15 |     {
16 |         return $this->hasModel()
17 |             ? Html::activeRadioList($this->model, $this->attribute, $this->items, $this->options)
18 |             : Html::radioList($this->name, $this->selection, $this->items, $this->options);
19 |     }
20 | 
21 |     /**
22 |      * @return callable
23 |      */
24 |     public function getDefaultItem()
25 |     {
26 |         return function ($index, $label, $name, $checked, $value) {
27 |             $inputOptions = $this->inputOptions;
28 |             $inputOptions['value'] = ArrayHelper::getValue($inputOptions, 'value', $value);
29 |             return Html::tag(
30 |                 'div',
31 |                 Radio::widget([
32 |                     'name' => $name,
33 |                     'label' => $label,
34 |                     'checked' => $checked,
35 |                     'inputOptions' => $inputOptions,
36 |                     'labelOptions' => $this->labelOptions
37 |                 ]),
38 |                 ['class' => 'field']
39 |             );
40 |         };
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/modules/Rating.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\Html;
 7 | use yii\helpers\Json;
 8 | use Zelenin\yii\SemanticUI\Widget;
 9 | 
10 | class Rating extends Widget
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     public $type;
16 |     const TYPE_STAR = 'star';
17 |     const TYPE_HEART = 'heart';
18 | 
19 |     /**
20 |      * @var string
21 |      */
22 |     public $size;
23 | 
24 |     public function run()
25 |     {
26 |         $this->registerJs();
27 | 
28 |         Html::addCssClass($this->options, 'ui rating');
29 | 
30 |         if ($this->type) {
31 |             Html::addCssClass($this->options, $this->type);
32 |         }
33 |         if ($this->size) {
34 |             Html::addCssClass($this->options, $this->size);
35 |         }
36 | 
37 |         echo Html::tag('div', '', $this->options);
38 |     }
39 | 
40 |     public function registerJs()
41 |     {
42 |         $this->registerJsAsset();
43 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
44 |         $this->getView()->registerJs('jQuery("#' . $this->getId() . '").rating(' . $clientOptions . ');');
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/modules/Search.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\Html;
 7 | use yii\helpers\Json;
 8 | use Zelenin\yii\SemanticUI\Elements;
 9 | use Zelenin\yii\SemanticUI\Widget;
10 | 
11 | class Search extends Widget
12 | {
13 |     /**
14 |      * @var string
15 |      */
16 |     public $input;
17 | 
18 |     /**
19 |      * @var bool
20 |      */
21 |     public $loading = true;
22 |     const TYPE_LOADING = 'loading';
23 | 
24 |     /**
25 |      * @var bool
26 |      */
27 |     public $fluid = false;
28 |     const TYPE_FLUID = 'fluid';
29 | 
30 |     /**
31 |      * @var bool
32 |      */
33 |     public $category = false;
34 |     const TYPE_CATEGORY = 'category';
35 | 
36 |     /**
37 |      * @var bool
38 |      */
39 |     public $rightAligned = false;
40 |     const TYPE_RIGHT_ALIGNED = 'right aligned';
41 | 
42 |     public function run()
43 |     {
44 |         $this->registerJs();
45 | 
46 |         Html::addCssClass($this->options, 'ui search');
47 |         if ($this->loading) {
48 |             Html::addCssClass($this->options, self::TYPE_LOADING);
49 |         }
50 |         if ($this->fluid) {
51 |             Html::addCssClass($this->options, self::TYPE_FLUID);
52 |         }
53 |         if ($this->category) {
54 |             Html::addCssClass($this->options, self::TYPE_CATEGORY);
55 |         }
56 |         if ($this->rightAligned) {
57 |             Html::addCssClass($this->options, self::TYPE_RIGHT_ALIGNED);
58 |         }
59 | 
60 |         echo Html::tag('div', $this->renderInput() . $this->renderResults(), $this->options);
61 |     }
62 | 
63 |     /**
64 |      * @return string
65 |      */
66 |     public function renderInput()
67 |     {
68 |         return $this->input ?: Elements::input(Html::input('text', null, null, ['class' => 'prompt']));
69 |     }
70 | 
71 |     /**
72 |      * @return string
73 |      */
74 |     public function renderResults()
75 |     {
76 |         return Html::tag('div', null, ['class' => 'results']);
77 |     }
78 | 
79 |     public function registerJs()
80 |     {
81 |         $this->registerJsAsset();
82 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
83 |         $this->getView()->registerJs('jQuery("#' . $this->options['id'] . '").search(' . $clientOptions . ');');
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/modules/Select.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\Html;
 7 | use yii\helpers\Json;
 8 | use yii\web\View;
 9 | use Zelenin\yii\SemanticUI\InputWidget;
10 | 
11 | class Select extends InputWidget
12 | {
13 |     /**
14 |      * @var array
15 |      */
16 |     public $items = [];
17 | 
18 |     /**
19 |      * @var mixed
20 |      */
21 |     public $selection = null;
22 | 
23 |     /**
24 |      * @var bool
25 |      */
26 |     public $search = false;
27 |     const TYPE_SEARCH = 'search';
28 | 
29 |     /**
30 |      * @var bool
31 |      */
32 |     public $fluid = false;
33 |     const TYPE_FLUID = 'fluid';
34 | 
35 |     /**
36 |      * @var bool
37 |      */
38 |     public $compact = false;
39 |     const TYPE_COMPACT = 'compact';
40 | 
41 |     /**
42 |      * @var bool
43 |      */
44 |     public $disabled = false;
45 |     const TYPE_DISABLED = 'disabled';
46 | 
47 |     /**
48 |      * @var bool
49 |      */
50 |     public $upward = false;
51 |     const TYPE_UPWARD = 'upward';
52 | 
53 |     /**
54 |      * @var bool
55 |      */
56 |     public $multiple = false;
57 | 
58 |     public function run()
59 |     {
60 |         $this->registerJs();
61 | 
62 |         Html::addCssClass($this->options, 'ui dropdown');
63 | 
64 |         if ($this->search) {
65 |             Html::addCssClass($this->options, self::TYPE_SEARCH);
66 |         }
67 |         if ($this->fluid) {
68 |             Html::addCssClass($this->options, self::TYPE_FLUID);
69 |         }
70 |         if ($this->disabled) {
71 |             Html::addCssClass($this->options, self::TYPE_DISABLED);
72 |         }
73 |         if ($this->compact) {
74 |             Html::addCssClass($this->options, self::TYPE_COMPACT);
75 |         }
76 |         if ($this->upward) {
77 |             Html::addCssClass($this->options, self::TYPE_UPWARD);
78 |         }
79 |         if ($this->multiple) {
80 |             $this->options['multiple'] = true;
81 |         }
82 | 
83 |         echo $this->hasModel()
84 |             ? Html::activeDropDownList($this->model, $this->attribute, $this->items, $this->options)
85 |             : Html::dropDownList($this->name, $this->selection, $this->items, $this->options);
86 |     }
87 | 
88 |     public function registerJs()
89 |     {
90 |         $this->registerJsAsset();
91 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
92 |         $this->getView()->registerJs('jQuery("#' . $this->options['id'] . '").dropdown(' . $clientOptions . ');', View::POS_END);
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/modules/Shape.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\modules;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\Html;
  7 | use yii\helpers\Json;
  8 | use Zelenin\yii\SemanticUI\Widget;
  9 | 
 10 | class Shape extends Widget
 11 | {
 12 |     /**
 13 |      * @var array
 14 |      */
 15 |     public $sides = [];
 16 | 
 17 |     /**
 18 |      * @var string
 19 |      */
 20 |     public $type;
 21 |     const TYPE_CUBE = 'cube';
 22 |     const TYPE_TEXT = 'text';
 23 | 
 24 |     /**
 25 |      * @var bool
 26 |      */
 27 |     public $fluid = false;
 28 |     const TYPE_FLUID = 'fluid';
 29 | 
 30 |     /**
 31 |      * @var bool
 32 |      */
 33 |     public $compact = false;
 34 |     const TYPE_COMPACT = 'compact';
 35 | 
 36 |     /**
 37 |      * @var bool
 38 |      */
 39 |     public $disabled = false;
 40 |     const TYPE_DISABLED = 'disabled';
 41 | 
 42 |     /**
 43 |      * @var bool
 44 |      */
 45 |     public $upward = false;
 46 |     const TYPE_UPWARD = 'upward';
 47 | 
 48 |     public function run()
 49 |     {
 50 |         $this->registerJs();
 51 | 
 52 |         Html::addCssClass($this->options, 'ui shape');
 53 | 
 54 |         if ($this->type) {
 55 |             Html::addCssClass($this->options, $this->type);
 56 |         }
 57 | 
 58 |         echo Html::tag('div', Html::tag('div', $this->renderSides(), ['class' => 'sides']), $this->options);
 59 |     }
 60 | 
 61 |     /**
 62 |      * @return string
 63 |      */
 64 |     public function renderSides()
 65 |     {
 66 |         $sides = '';
 67 |         foreach ($this->normalizeSides($this->sides) as $side) {
 68 |             $sides .= $this->renderSide($side);
 69 |         }
 70 |         return $sides;
 71 |     }
 72 | 
 73 |     /**
 74 |      * @param array $side
 75 |      * @return string
 76 |      */
 77 |     public function renderSide($side)
 78 |     {
 79 |         $sideOptions = ['class' => 'side'];
 80 |         if ($side['active']) {
 81 |             Html::addCssClass($sideOptions, 'active');
 82 |         }
 83 |         return Html::tag('div', $side['content'], $sideOptions);
 84 |     }
 85 | 
 86 |     /**
 87 |      * @param array $sides
 88 |      * @return array
 89 |      */
 90 |     public function normalizeSides($sides)
 91 |     {
 92 |         $items = [];
 93 |         $isActive = false;
 94 |         foreach ($sides as $side) {
 95 |             if (isset($side['active'])) {
 96 |                 if ($side['active'] && !$isActive) {
 97 |                     $isActive = true;
 98 |                 }
 99 |             } else {
100 |                 $side['active'] = false;
101 |             }
102 |             $items[] = $side;
103 |         }
104 |         if (!$isActive && isset($items[0])) {
105 |             $items[0]['active'] = true;
106 |         }
107 |         return $items;
108 |     }
109 | 
110 |     public function registerJs()
111 |     {
112 |         $this->registerJsAsset();
113 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
114 |         $this->getView()->registerJs('jQuery("#' . $this->getId() . '").shape(' . $clientOptions . ');');
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/modules/Sidebar.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\Html;
 7 | use yii\helpers\Json;
 8 | use Zelenin\yii\SemanticUI\Widget;
 9 | 
10 | class Sidebar extends Widget
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     public $content;
16 | 
17 |     /**
18 |      * @var bool
19 |      */
20 |     public $visible = false;
21 |     const TYPE_VISIBLE = 'visible';
22 | 
23 |     /**
24 |      * @var string
25 |      */
26 |     public $width;
27 |     const WIDTH_THIN = 'thin';
28 |     const WIDTH_VERY_THIN = 'very thin';
29 |     const WIDTH_WIDE = 'wide';
30 |     const WIDTH_VERY_WIDE = 'very wide';
31 | 
32 |     public function run()
33 |     {
34 |         $this->registerJs();
35 | 
36 |         Html::addCssClass($this->options, 'ui sidebar');
37 | 
38 |         if ($this->visible) {
39 |             Html::addCssClass($this->options, self::TYPE_VISIBLE);
40 |         }
41 |         if ($this->width) {
42 |             Html::addCssClass($this->options, $this->width);
43 |         }
44 | 
45 |         echo Html::tag('div', $this->content, $this->options);
46 |     }
47 | 
48 |     public function registerJs()
49 |     {
50 |         $this->registerJsAsset();
51 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
52 |         $this->getView()->registerJs('jQuery("#' . $this->getId() . '").sidebar(' . $clientOptions . ');');
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/modules/Sticky.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\modules;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\Html;
 7 | use yii\helpers\Json;
 8 | use Zelenin\yii\SemanticUI\Widget;
 9 | 
10 | class Sticky extends Widget
11 | {
12 |     public function init()
13 |     {
14 |         parent::init();
15 | 
16 |         $this->registerJs();
17 | 
18 |         Html::addCssClass($this->options, 'ui sticky');
19 |         echo Html::beginTag('div', $this->options);
20 |     }
21 | 
22 |     public function run()
23 |     {
24 |         echo Html::endTag('div');
25 |     }
26 | 
27 |     public function registerJs()
28 |     {
29 |         $this->registerJsAsset();
30 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
31 |         $this->getView()->registerJs('jQuery("#' . $this->options['id'] . '").sticky(' . $clientOptions . ');');
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/modules/Tab.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\modules;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\ArrayHelper;
  7 | use yii\helpers\Html;
  8 | use yii\helpers\Json;
  9 | use Zelenin\yii\SemanticUI\Widget;
 10 | 
 11 | class Tab extends Widget
 12 | {
 13 |     /**
 14 |      * @var array
 15 |      */
 16 |     public $items = [];
 17 | 
 18 |     /**
 19 |      * @var array
 20 |      */
 21 |     public $labelOptions = [];
 22 | 
 23 |     /**
 24 |      * @var array
 25 |      */
 26 |     public $contentOptions = [
 27 |         'class' => 'bottom attached segment'
 28 |     ];
 29 | 
 30 |     /**
 31 |      * @var array
 32 |      */
 33 |     public $options = [
 34 |         'class' => 'ui top attached tabular menu'
 35 |     ];
 36 | 
 37 |     const STATE_ACTIVE = 'active';
 38 | 
 39 |     public function run()
 40 |     {
 41 |         $this->registerJs();
 42 |         $this->normalizeItems();
 43 | 
 44 |         echo $this->renderMenu() . $this->renderTabs();
 45 |     }
 46 | 
 47 |     /**
 48 |      * @return string
 49 |      */
 50 |     public function renderMenu()
 51 |     {
 52 |         $items = '';
 53 |         foreach ($this->items as $item) {
 54 |             Html::addCssClass($item['labelOptions'], 'item');
 55 |             $item['labelOptions']['data-tab'] = $item['uniqueId'];
 56 |             if ($item[self::STATE_ACTIVE]) {
 57 |                 Html::addCssClass($item['labelOptions'], self::STATE_ACTIVE);
 58 |             }
 59 |             $items .= Html::a($item['label'], null, $item['labelOptions']);
 60 |         }
 61 |         return Html::tag('div', $items, $this->options);
 62 |     }
 63 | 
 64 |     /**
 65 |      * @return string
 66 |      */
 67 |     public function renderTabs()
 68 |     {
 69 |         $items = '';
 70 |         foreach ($this->items as $item) {
 71 |             Html::addCssClass($item['contentOptions'], 'ui tab');
 72 |             $item['contentOptions']['data-tab'] = $item['uniqueId'];
 73 |             if ($item[self::STATE_ACTIVE]) {
 74 |                 Html::addCssClass($item['contentOptions'], self::STATE_ACTIVE);
 75 |             }
 76 |             $items .= Html::tag('div', $item['content'], $item['contentOptions']);
 77 |         }
 78 |         return $items;
 79 |     }
 80 | 
 81 |     public function normalizeItems()
 82 |     {
 83 |         $items = [];
 84 |         $i = 1;
 85 |         $isActive = false;
 86 |         foreach ($this->items as $item) {
 87 |             $item['labelOptions'] = array_merge($this->labelOptions, ArrayHelper::getValue($item, 'labelOptions', []));
 88 |             $item['contentOptions'] = array_merge($this->contentOptions, ArrayHelper::getValue($item, 'contentOptions', []));
 89 |             if (!array_key_exists('uniqueId', $item)) {
 90 |                 $item['uniqueId'] = $this->getId() . '-tab-' . $i;
 91 |             }
 92 | 
 93 |             if (isset($item[self::STATE_ACTIVE])) {
 94 |                 if ($item[self::STATE_ACTIVE] && !$isActive) {
 95 |                     $isActive = true;
 96 |                 }
 97 |             } else {
 98 |                 $item[self::STATE_ACTIVE] = false;
 99 |             }
100 | 
101 |             $items[] = $item;
102 |             $i++;
103 |         }
104 |         if (!$isActive && isset($items[0])) {
105 |             $items[0][self::STATE_ACTIVE] = true;
106 |         }
107 |         $this->items = $items;
108 |     }
109 | 
110 |     public function registerJs()
111 |     {
112 |         $this->registerJsAsset();
113 |         $clientOptions = $this->clientOptions ? Json::encode($this->clientOptions) : null;
114 |         $this->getView()->registerJs('jQuery("#' . $this->getId() . ' .item").tab(' . $clientOptions . ');');
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Yii2 Semantic UI extension
 2 | 
 3 | [Semantic UI](http://semantic-ui.com) extension for [Yii2](http://www.yiiframework.com)
 4 | 
 5 | ## Installation
 6 | 
 7 | yii2-semantic-ui 2.* works with Semantic UI 2.*
 8 | 
 9 | ### Composer
10 | 
11 | The preferred way to install this extension is through [Composer](http://getcomposer.org/).
12 | 
13 | Either run
14 | 
15 | ```
16 | php composer.phar require zelenin/yii2-semantic-ui "~2"
17 | ```
18 | 
19 | or add
20 | 
21 | ```
22 | "zelenin/yii2-semantic-ui": "~2"
23 | ```
24 | 
25 | to the require section of your ```composer.json```
26 | 
27 | ## Usage
28 | 
29 | Add SemanticUICSSAsset to AppAsset:
30 | 
31 | ```php
32 | <?php
33 | 
34 | namespace backend\assets;
35 | 
36 | use yii\web\AssetBundle;
37 | 
38 | class AppAsset extends AssetBundle
39 | {
40 |     public $basePath = '@webroot';
41 |     public $baseUrl = '@web';
42 |     public $css = [];
43 |     public $js = [];
44 |     public $depends = [
45 |         'yii\web\YiiAsset',
46 |         'yii\web\JqueryAsset',
47 |         'Zelenin\yii\SemanticUI\assets\SemanticUICSSAsset'
48 |     ];
49 | }
50 | ```
51 | 
52 | Use Semantic UI widgets and elements. Standard Yii2 widgets also adopted.
53 | 
54 | You may replace yii2 standard widgets. Write in bootstrap.php:
55 | 
56 | ```php
57 | Yii::$container->set(\yii\grid\GridView::className(), \Zelenin\yii\SemanticUI\widgets\GridView::className());
58 | Yii::$container->set(\yii\widgets\ActiveForm::className(), \Zelenin\yii\SemanticUI\widgets\ActiveForm::className());
59 | Yii::$container->set(\yii\bootstrap\ActiveForm::className(), \Zelenin\yii\SemanticUI\widgets\ActiveForm::className());
60 | Yii::$container->set(\yii\widgets\Breadcrumbs::className(), \Zelenin\yii\SemanticUI\collections\Breadcrumb::className());
61 | Yii::$container->set(\yii\grid\CheckboxColumn::className(), \Zelenin\yii\SemanticUI\widgets\CheckboxColumn::className());
62 | ```
63 | 
64 | Be very careful with it.
65 | 
66 | ## Author
67 | 
68 | [Aleksandr Zelenin](https://github.com/zelenin/), e-mail: [aleksandr@zelenin.me](mailto:aleksandr@zelenin.me)
69 | 


--------------------------------------------------------------------------------
/widgets/ActionColumn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\widgets;
 4 | 
 5 | use Yii;
 6 | use yii\helpers\Html;
 7 | use Zelenin\yii\SemanticUI\Elements;
 8 | 
 9 | class ActionColumn extends \yii\grid\ActionColumn
10 | {
11 |     /**
12 |      * @var string
13 |      */
14 |     public $template = '<div class="ui basic tiny compact icon buttons">{view}{update}{delete}</div>';
15 | 
16 |     protected function initDefaultButtons()
17 |     {
18 |         if (!isset($this->buttons['view'])) {
19 |             $this->buttons['view'] = function ($url, $model, $key) {
20 |                 return Html::a(Elements::icon('eye'), $url, [
21 |                     'class' => 'ui button',
22 |                     'title' => Yii::t('yii', 'View'),
23 |                     'data-pjax' => '0',
24 |                 ]);
25 |             };
26 |         }
27 |         if (!isset($this->buttons['update'])) {
28 |             $this->buttons['update'] = function ($url, $model, $key) {
29 |                 return Html::a(Elements::icon('pencil'), $url, [
30 |                     'class' => 'ui button',
31 |                     'title' => Yii::t('yii', 'Update'),
32 |                     'data-pjax' => '0',
33 |                 ]);
34 |             };
35 |         }
36 |         if (!isset($this->buttons['delete'])) {
37 |             $this->buttons['delete'] = function ($url, $model, $key) {
38 |                 return Html::a(Elements::icon('trash'), $url, [
39 |                     'class' => 'ui button',
40 |                     'title' => Yii::t('yii', 'Delete'),
41 |                     'data-confirm' => Yii::t('yii', 'Are you sure you want to delete this item?'),
42 |                     'data-method' => 'post',
43 |                     'data-pjax' => '0',
44 |                 ]);
45 |             };
46 |         }
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/widgets/ActiveField.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\widgets;
  4 | 
  5 | use Yii;
  6 | use yii\helpers\ArrayHelper;
  7 | use yii\helpers\Html;
  8 | use Zelenin\yii\SemanticUI\modules\Checkbox;
  9 | use Zelenin\yii\SemanticUI\modules\CheckboxList;
 10 | use Zelenin\yii\SemanticUI\modules\Dropdown;
 11 | use Zelenin\yii\SemanticUI\modules\RadioList;
 12 | 
 13 | class ActiveField extends \yii\widgets\ActiveField
 14 | {
 15 |     public $labelOptions = [];
 16 | 
 17 |     public $options = ['class' => 'field'];
 18 |     public $inputOptions = [];
 19 | 
 20 |     public $errorOptions = ['class' => 'ui red pointing label'];
 21 |     public $hintOptions = ['class' => 'ui pointing label'];
 22 | 
 23 |     public $template = "{label}\n{input}\n{hint}\n{error}";
 24 |     public $checkboxTemplate = '<div class="ui checkbox">{input}{label}{hint}{error}</div>';
 25 | 
 26 |     public function render($content = null)
 27 |     {
 28 |         $this->registerStyles();
 29 |         return parent::render($content);
 30 |     }
 31 | 
 32 |     public function registerStyles()
 33 |     {
 34 |         $classNamesToSelectors = function ($classNames) {
 35 |             return '.' . implode('.', preg_split('/\s+/', $classNames, -1, PREG_SPLIT_NO_EMPTY));
 36 |         };
 37 |         $this->form->getView()->registerCss('
 38 |         ' . $classNamesToSelectors($this->errorOptions['class']) . ' {
 39 |             display: none;
 40 |         }
 41 |         ' . $classNamesToSelectors($this->form->errorCssClass) . ' ' . $classNamesToSelectors($this->errorOptions['class']) . ' {
 42 |             display: inline-block;
 43 |         }
 44 |         ');
 45 |     }
 46 | 
 47 |     public function checkbox($options = [], $enclosedByLabel = true)
 48 |     {
 49 |         $this->parts['{label}'] = '';
 50 |         $this->parts['{input}'] = Checkbox::widget([
 51 |             'class' => Checkbox::className(),
 52 |             'model' => $this->model,
 53 |             'attribute' => $this->attribute,
 54 |             'options' => $options,
 55 |             'label' => Html::activeLabel($this->model, $this->attribute, $this->labelOptions)
 56 |         ]);
 57 |         return $this;
 58 |     }
 59 | 
 60 |     public function checkboxList($items, $options = [])
 61 |     {
 62 |         $this->parts['{input}'] = CheckboxList::widget([
 63 |             'class' => CheckboxList::className(),
 64 |             'model' => $this->model,
 65 |             'attribute' => $this->attribute,
 66 |             'items' => $items,
 67 |             'options' => $options
 68 |         ]);
 69 |         return $this;
 70 |     }
 71 | 
 72 |     public function radioList($items, $options = [])
 73 |     {
 74 |         $this->parts['{input}'] = RadioList::widget([
 75 |             'class' => RadioList::className(),
 76 |             'model' => $this->model,
 77 |             'attribute' => $this->attribute,
 78 |             'items' => $items,
 79 |             'options' => $options
 80 |         ]);
 81 |         return $this;
 82 |     }
 83 | 
 84 |     public function dropDownList($items, $options = [])
 85 |     {
 86 |         $multiple = ArrayHelper::remove($options, 'multiple', false);
 87 |         $upward = ArrayHelper::remove($options, 'upward', false);
 88 |         $compact = ArrayHelper::remove($options, 'compact', false);
 89 |         $disabled = ArrayHelper::remove($options, 'disabled', false);
 90 |         $fluid = ArrayHelper::remove($options, 'fluid', false);
 91 |         $search = ArrayHelper::remove($options, 'search', true);
 92 |         $defaultText = ArrayHelper::remove($options, 'defaultText', '');
 93 | 
 94 |         $this->parts['{input}'] = Dropdown::widget([
 95 |             'class' => Dropdown::className(),
 96 |             'model' => $this->model,
 97 |             'attribute' => $this->attribute,
 98 |             'items' => $items,
 99 |             'options' => $options,
100 |             'search' => $search,
101 |             'multiple' => $multiple,
102 |             'upward' => $upward,
103 |             'compact' => $compact,
104 |             'disabled' => $disabled,
105 |             'fluid' => $fluid,
106 |             'defaultText' => $defaultText
107 |         ]);
108 |         return $this;
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/widgets/ActiveForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\widgets;
 4 | 
 5 | use yii\helpers\Html;
 6 | 
 7 | class ActiveForm extends \yii\widgets\ActiveForm
 8 | {
 9 |     public $fieldClass = 'Zelenin\yii\SemanticUI\widgets\ActiveField';
10 |     public $options = ['class' => 'ui form'];
11 |     public $errorCssClass = 'error';
12 |     public $successCssClass = 'success';
13 | 
14 |     /**
15 |      * @var string
16 |      */
17 |     public $size;
18 | 
19 |     /**
20 |      * @var bool
21 |      */
22 |     public $inverted = false;
23 | 
24 |     public function init()
25 |     {
26 |         if ($this->size) {
27 |             Html::addCssClass($this->options, $this->size);
28 |         }
29 | 
30 |         if ($this->inverted === true) {
31 |             Html::addCssClass($this->options, 'inverted');
32 |         }
33 |         parent::init();
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/widgets/CheckboxColumn.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\yii\SemanticUI\widgets;
  4 | 
  5 | use Closure;
  6 | use Exception;
  7 | use yii\helpers\ArrayHelper;
  8 | use yii\helpers\Json;
  9 | use yii\web\JsExpression;
 10 | use Zelenin\yii\SemanticUI\modules\Checkbox;
 11 | 
 12 | class CheckboxColumn extends \yii\grid\CheckboxColumn
 13 | {
 14 |     /**
 15 |      * @return string
 16 |      *
 17 |      * @throws Exception
 18 |      */
 19 |     protected function renderHeaderCellContent()
 20 |     {
 21 |         $name = rtrim($this->name, '[]') . '_all';
 22 |         $id = $this->grid->options['id'];
 23 |         $options = json_encode([
 24 |             'name' => $this->name,
 25 |             'multiple' => $this->multiple,
 26 |             'checkAll' => $name,
 27 |         ], JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
 28 |         $this->grid->getView()->registerJs("jQuery('#$id').yiiGridView('setSelectionColumn', $options);");
 29 | 
 30 |         if ($this->header !== null || !$this->multiple) {
 31 |             return parent::renderHeaderCellContent();
 32 |         } else {
 33 |             return Checkbox::widget([
 34 |                 'name' => $name,
 35 |                 'checked' => false,
 36 |                 'inputOptions' => [
 37 |                     'class' => 'select-on-check-all'
 38 |                 ],
 39 |                 'clientOptions' => [
 40 |                     'onChecked' => new JsExpression('function() {
 41 |                         var $childCheckbox = $(this).closest("#' . $this->grid->options['id'] . '").find("input[name=\'' . $this->name . '\']").closest(".checkbox");
 42 |                         $childCheckbox.checkbox("check");
 43 |                     }'),
 44 |                     'onUnchecked' => new JsExpression('function() {
 45 |                         var $childCheckbox = $(this).closest("#' . $this->grid->options['id'] . '").find("input[name=\'' . $this->name . '\']").closest(".checkbox");
 46 |                         $childCheckbox.checkbox("uncheck");
 47 |                     }')
 48 |                 ]
 49 |             ]);
 50 |         }
 51 |     }
 52 | 
 53 |     /**
 54 |      * @param mixed $model
 55 |      * @param mixed $key
 56 |      * @param int $index
 57 |      *
 58 |      * @return string
 59 |      *
 60 |      * @throws Exception
 61 |      */
 62 |     protected function renderDataCellContent($model, $key, $index)
 63 |     {
 64 |         if ($this->checkboxOptions instanceof Closure) {
 65 |             $options = call_user_func($this->checkboxOptions, $model, $key, $index, $this);
 66 |         } else {
 67 |             $options = $this->checkboxOptions;
 68 |             if (!isset($options['value'])) {
 69 |                 $options['value'] = is_array($key) ? Json::encode($key) : $key;
 70 |             }
 71 |         }
 72 |         $options['id'] = ArrayHelper::getValue($options, 'id', rtrim($this->name, '[]') . '-' . $key);
 73 |         return Checkbox::widget([
 74 |             'name' => $this->name,
 75 |             'checked' => !empty($options['checked']),
 76 |             'inputOptions' => $options,
 77 |             'clientOptions' => [
 78 |                 'fireOnInit' => true,
 79 |                 'onChange' => new JsExpression('function() {
 80 |                     var $parentCheckbox = $(".select-on-check-all").closest(".checkbox"),
 81 |                     $checkbox = $("#' . $this->grid->options['id'] . '").find("input[name=\'' . $this->name . '\']").closest(".checkbox"),
 82 |                     allChecked = true,
 83 |                     allUnchecked = true;
 84 | 
 85 |                     $checkbox.each(function() {
 86 |                         if ($(this).checkbox("is checked")) {
 87 |                             allUnchecked = false;
 88 |                         } else {
 89 |                             allChecked = false;
 90 |                         }
 91 |                     });
 92 | 
 93 |                     if(allChecked) {
 94 |                         $parentCheckbox.checkbox("set checked");
 95 |                     } else if(allUnchecked) {
 96 |                         $parentCheckbox.checkbox("set unchecked");
 97 |                     } else {
 98 |                         $parentCheckbox.checkbox("set indeterminate");
 99 |                     }
100 |                 }'),
101 |             ]
102 |         ]);
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/widgets/DataColumn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\widgets;
 4 | 
 5 | use yii\base\Model;
 6 | use yii\helpers\Html;
 7 | use Zelenin\yii\SemanticUI\Elements;
 8 | use Zelenin\yii\SemanticUI\modules\Select;
 9 | 
10 | class DataColumn extends \yii\grid\DataColumn
11 | {
12 |     public $filterDropdownOptions = ['class' => 'ui fluid dropdown', 'id' => null];
13 |     public $filterInputOptions = ['class' => '', 'id' => null];
14 | 
15 |     protected function renderFilterCellContent()
16 |     {
17 |         if (is_string($this->filter)) {
18 |             return $this->filter;
19 |         }
20 | 
21 |         $model = $this->grid->filterModel;
22 | 
23 |         if ($this->filter !== false && $model instanceof Model && $this->attribute !== null && $model->isAttributeActive($this->attribute)) {
24 |             if ($model->hasErrors($this->attribute)) {
25 |                 $error = Html::error($model, $this->attribute, $this->grid->filterErrorOptions);
26 |             } else {
27 |                 $error = '';
28 |             }
29 |             if (is_array($this->filter)) {
30 |                 $options = array_merge(['prompt' => ''], $this->filterDropdownOptions);
31 |                 if ($model->hasErrors($this->attribute)) {
32 |                     Html::addCssClass($options, 'error');
33 |                 }
34 |                 return Select::widget([
35 |                     'model' => $model,
36 |                     'attribute' => $this->attribute,
37 |                     'items' => $this->filter,
38 |                     'options' => $options,
39 |                     'search' => true
40 |                 ]) . ' ' . $error;
41 |             } else {
42 |                 $options = ['class' => 'fluid'];
43 |                 if ($model->hasErrors($this->attribute)) {
44 |                     Html::addCssClass($options, 'error');
45 |                 }
46 |                 return Elements::input(Html::activeTextInput($model, $this->attribute, $this->filterInputOptions) . $error, $options);
47 |             }
48 |         } else {
49 |             return parent::renderFilterCellContent();
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/widgets/DetailView.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\widgets;
 4 | 
 5 | class DetailView extends \yii\widgets\DetailView
 6 | {
 7 |     public $options = ['class' => 'ui definition table'];
 8 |     public $template = '<tr><td>{label}</td><td>{value}</td></tr>';
 9 | }
10 | 


--------------------------------------------------------------------------------
/widgets/GridView.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\widgets;
 4 | 
 5 | class GridView extends \yii\grid\GridView
 6 | {
 7 |     /**
 8 |      * @var array
 9 |      */
10 |     public $tableOptions = ['class' => 'ui table'];
11 | 
12 |     /**
13 |      * @var string
14 |      */
15 |     public $dataColumnClass = 'Zelenin\yii\SemanticUI\widgets\DataColumn';
16 | 
17 |     /**
18 |      * @var array
19 |      */
20 |     public $pager = ['class' => 'Zelenin\yii\SemanticUI\widgets\LinkPager'];
21 | }
22 | 


--------------------------------------------------------------------------------
/widgets/LinkPager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\widgets;
 4 | 
 5 | use yii\helpers\Html;
 6 | 
 7 | class LinkPager extends \yii\widgets\LinkPager
 8 | {
 9 |     public $options = ['class' => 'ui pagination menu'];
10 |     public $linkOptions = ['class' => 'item'];
11 |     public $disabledPageCssClass = 'disabled item';
12 |     public $nextPageLabel = '<i class="right arrow icon"></i>';
13 |     public $prevPageLabel = '<i class="left arrow icon"></i>';
14 | 
15 |     protected function renderPageButtons()
16 |     {
17 |         $pageCount = $this->pagination->getPageCount();
18 |         if ($pageCount < 2 && $this->hideOnSinglePage) {
19 |             return '';
20 |         }
21 | 
22 |         $buttons = [];
23 |         $currentPage = $this->pagination->getPage();
24 | 
25 |         // first page
26 |         if ($this->firstPageLabel !== false) {
27 |             $buttons[] = $this->renderPageButton($this->firstPageLabel, 0, $this->firstPageCssClass, $currentPage <= 0, false);
28 |         }
29 | 
30 |         // prev page
31 |         if ($this->prevPageLabel !== false) {
32 |             if (($page = $currentPage - 1) < 0) {
33 |                 $page = 0;
34 |             }
35 |             $buttons[] = $this->renderPageButton($this->prevPageLabel, $page, $this->prevPageCssClass, $currentPage <= 0, false);
36 |         }
37 | 
38 |         // internal pages
39 |         list($beginPage, $endPage) = $this->getPageRange();
40 |         for ($i = $beginPage; $i <= $endPage; ++$i) {
41 |             $buttons[] = $this->renderPageButton($i + 1, $i, null, false, $i == $currentPage);
42 |         }
43 | 
44 |         // next page
45 |         if ($this->nextPageLabel !== false) {
46 |             if (($page = $currentPage + 1) >= $pageCount - 1) {
47 |                 $page = $pageCount - 1;
48 |             }
49 |             $buttons[] = $this->renderPageButton($this->nextPageLabel, $page, $this->nextPageCssClass, $currentPage >= $pageCount - 1, false);
50 |         }
51 | 
52 |         // last page
53 |         if ($this->lastPageLabel !== false) {
54 |             $buttons[] = $this->renderPageButton($this->lastPageLabel, $pageCount - 1, $this->lastPageCssClass, $currentPage >= $pageCount - 1, false);
55 |         }
56 | 
57 |         return Html::tag('div', implode("\n", $buttons), $this->options);
58 |     }
59 | 
60 |     protected function renderPageButton($label, $page, $class, $disabled, $active)
61 |     {
62 |         $options = ['class' => $class === '' ? null : $class];
63 |         if ($disabled) {
64 |             Html::addCssClass($options, $this->disabledPageCssClass);
65 |             return Html::tag('div', Html::tag('span', $label), $options);
66 |         }
67 |         $linkOptions = $this->linkOptions;
68 |         $linkOptions['data-page'] = $page;
69 | 
70 |         if ($active) {
71 |             Html::addCssClass($linkOptions, $this->activePageCssClass);
72 |         }
73 |         return Html::a($label, $this->pagination->createUrl($page), $linkOptions);
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/widgets/Pjax.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\yii\SemanticUI\widgets;
 4 | 
 5 | use yii\helpers\Html;
 6 | use yii\helpers\Inflector;
 7 | use Zelenin\yii\SemanticUI\Elements;
 8 | 
 9 | class Pjax extends \yii\widgets\Pjax
10 | {
11 |     /**
12 |      * @var string
13 |      */
14 |     public $loader;
15 | 
16 |     public function init()
17 |     {
18 |         Html::addCssClass($this->options, 'dimmable');
19 |         if (!$this->loader) {
20 |             $this->loader = Elements::dimmer(Elements::loader(), ['class' => 'active inverted']);
21 |         }
22 |         parent::init();
23 |     }
24 | 
25 |     public function registerClientScript()
26 |     {
27 |         parent::registerClientScript();
28 |         $this->getView()->registerJs('
29 |         var pjaxLoader_' . $this->getSanitizedId() . ' = "' . addslashes($this->loader) . '";
30 |         jQuery(document).on("pjax:start", "#' . $this->options['id'] . '", function() {
31 |             jQuery("#' . $this->options['id'] . '").append(pjaxLoader_' . $this->getSanitizedId() . ');
32 |         });
33 |         ');
34 |     }
35 | 
36 |     /**
37 |      * @return string
38 |      */
39 |     private function getSanitizedId()
40 |     {
41 |         return Inflector::camelize($this->options['id']);
42 |     }
43 | }
44 | 


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