1: <?php
  2: /**
  3:  * This file contains the cContentTypeTeaser class.
  4:  *
  5:  * @package Core
  6:  * @subpackage ContentType
  7:  * @version SVN Revision $Rev:$
  8:  *
  9:  * @author Timo Trautmann, Simon Sprankel
 10:  * @copyright four for business AG <www.4fb.de>
 11:  * @license http://www.contenido.org/license/LIZENZ.txt
 12:  * @link http://www.4fb.de
 13:  * @link http://www.contenido.org
 14:  */
 15: defined('CON_FRAMEWORK') || die('Illegal call: Missing framework initialization - request aborted.');
 16: 
 17: cInclude('includes', 'functions.con.php');
 18: cInclude('includes', 'functions.api.images.php');
 19: 
 20: /**
 21:  * Content type CMS_TEASER which lets the editor select articles in various ways
 22:  * which are displayed as teasers.
 23:  *
 24:  * @package Core
 25:  * @subpackage ContentType
 26:  */
 27: class cContentTypeTeaser extends cContentTypeAbstractTabbed {
 28: 
 29:     /**
 30:      * Array which contains all avariable CMS_Types and its ids
 31:      * in current CONTENIDO isntallation (described as hash [idtype =>
 32:      * cmstypename])
 33:      *
 34:      * @var array
 35:      */
 36:     private $_cmsTypes;
 37: 
 38:     /**
 39:      * Content types in this array will be completely ignored by CMS_TEASER
 40:      * They won't be displayed in the frontend and they won't be shown as an
 41:      * option in the backend
 42:      *
 43:      * @var array
 44:      */
 45:     private $_ignoreTypes = array();
 46: 
 47:     /**
 48:      * If CMS_TEASER tries to load one of the content types listed as the keys
 49:      * of this array it will load the value of that key instead
 50:      * These won't be listed as an option in the backend either
 51:      *
 52:      * @var array
 53:      */
 54:     private $_forwardTypes = array(
 55:         "CMS_EASYIMG" => "CMS_IMGEDITOR",
 56:         "CMS_IMG" => "CMS_IMGEDITOR",
 57:         "CMS_LINK" => "CMS_LINKEDITOR"
 58:     );
 59: 
 60:     /**
 61:      * Placeholders for labels in frontend.
 62:      * Important: This must be a static array!
 63:      *
 64:      * @var array
 65:      */
 66:     protected static $_translations = array(
 67:         "MORE"
 68:     );
 69: 
 70:     /**
 71:      * Variable for detecting current interation
 72:      */
 73:     protected $iteration = 0;
 74: 
 75:     /**
 76:      * Initialises class attributes and handles store events.
 77:      *
 78:      * @param string $rawSettings the raw settings in an XML structure or as
 79:      *        plaintext
 80:      * @param int $id ID of the content type, e.g. 3 if CMS_DATE[3] is
 81:      *        used
 82:      * @param array $contentTypes array containing the values of all content
 83:      *        types
 84:      */
 85:     public function __construct($rawSettings, $id, array $contentTypes) {
 86:         // change attributes from the parent class and call the parent
 87:         // constructor
 88:         $this->_type = 'CMS_TEASER';
 89:         $this->_prefix = 'teaser';
 90:         $this->_settingsType = self::SETTINGS_TYPE_XML;
 91:         $this->_formFields = array(
 92:             'teaser_title',
 93:             'teaser_category',
 94:             'teaser_count',
 95:             'teaser_style',
 96:             'teaser_manual',
 97:             'teaser_start',
 98:             'teaser_source_head',
 99:             'teaser_source_head_count',
100:             'teaser_source_text',
101:             'teaser_source_text_count',
102:             'teaser_source_image',
103:             'teaser_source_image_count',
104:             'teaser_filter',
105:             'teaser_sort',
106:             'teaser_sort_order',
107:             'teaser_character_limit',
108:             'teaser_image_width',
109:             'teaser_image_height',
110:             'teaser_manual_art',
111:             'teaser_image_crop',
112:             'teaser_source_date',
113:             'teaser_source_date_count'
114:         );
115: 
116:         parent::__construct($rawSettings, $id, $contentTypes);
117: 
118:         // if form is submitted, store the current teaser settings
119:         // notice: also check the ID of the content type (there could be more
120:         // than one content type of the same type on the same page!)
121:         if (isset($_POST[$this->_prefix . '_action']) && $_POST[$this->_prefix . '_action'] == 'store' && isset($_POST[$this->_prefix . '_id']) && (int) $_POST[$this->_prefix . '_id'] == $this->_id) {
122:             $this->_storeSettings();
123:         }
124: 
125:         $this->_setDefaultValues();
126:     }
127: 
128:     /**
129:      * Returns all translation strings for mi18n.
130:      *
131:      * @param array $translationStrings translation strings
132:      * @return array updated translation string
133:      */
134:     public static function addModuleTranslations(array $translationStrings) {
135:         foreach (self::$_translations as $value) {
136:             $translationStrings[] = $value;
137:         }
138: 
139:         return $translationStrings;
140:     }
141: 
142:     /**
143:      * Sets some default values for teaser in case that there is no value
144:      * defined.
145:      */
146:     private function _setDefaultValues() {
147:         // character limit is 120 by default
148:         if ((int) $this->_settings['teaser_character_limit'] == 0) {
149:             $this->_settings['teaser_character_limit'] = 120;
150:         }
151: 
152:         // teaser cont is 6 by default
153:         if ((int) $this->_settings['teaser_count'] == 0) {
154:             $this->_settings['teaser_count'] = 6;
155:         }
156: 
157:         // teasersort is creationdate by default
158:         if (strlen($this->_settings['teaser_sort']) == 0) {
159:             $this->_settings['teaser_sort'] = 'creationdate';
160:         }
161: 
162:         // teaser style is liststyle by default
163:         if (strlen($this->_settings['teaser_style']) == 0) {
164:             $this->_settings['teaser_style'] = 'cms_teaser_slider.html';
165:         }
166: 
167:         // teaser image width default
168:         if ((int) $this->_settings['teaser_image_width'] == 0) {
169:             $this->_settings['teaser_image_width'] = 100;
170:         }
171: 
172:         // teaser image height default
173:         if ((int) $this->_settings['teaser_image_height'] == 0) {
174:             $this->_settings['teaser_image_height'] = 75;
175:         }
176: 
177:         // cms type head default
178:         if (strlen($this->_settings['teaser_source_head']) == 0) {
179:             $this->_settings['teaser_source_head'] = 'CMS_HTMLHEAD';
180:         }
181: 
182:         // cms type text default
183:         if (strlen($this->_settings['teaser_source_text']) == 0) {
184:             $this->_settings['teaser_source_text'] = 'CMS_HTML';
185:         }
186: 
187:         // cms type image default
188:         if (strlen($this->_settings['teaser_source_image']) == 0) {
189:             $this->_settings['teaser_source_image'] = 'CMS_IMG';
190:         }
191: 
192:         // cms type date default
193:         if (strlen($this->_settings['teaser_source_date']) == 0) {
194:             $this->_settings['teaser_source_date'] = 'CMS_DATE';
195:         }
196: 
197:         // sort order of teaser articles
198:         if (strlen($this->_settings['teaser_sort_order']) == 0) {
199:             $this->_settings['teaser_sort_order'] = 'asc';
200:         }
201: 
202:         // teaser image crop option
203:         if (strlen($this->_settings['teaser_image_crop']) == 0 || $this->_settings['teaser_image_crop'] == 'false') {
204:             $this->_settings['teaser_image_crop'] = 'false';
205:         }
206:     }
207: 
208:     /**
209:      * Generates the code which should be shown if this content type is shown in
210:      * the frontend.
211:      *
212:      * @return string escaped HTML code which sould be shown if content type is
213:      *         shown in frontend
214:      */
215:     public function generateViewCode() {
216:         $code = '";?><?php
217:                     $teaser = new cContentTypeTeaser(\'%s\', %s, %s);
218: 
219:                     echo $teaser->generateTeaserCode();
220:                  ?><?php echo "';
221:         $code = sprintf($code, $this->_rawSettings, $this->_id, 'array()');
222: 
223:         return $code;
224:     }
225: 
226:     /**
227:      * Function returns idarts of selected articles as array
228:      *
229:      * @return array
230:      */
231:     public function getConfiguredArticles() {
232:         $articles = array();
233:         $articles = $this->generateTeaserCode(true);
234: 
235:         return $articles;
236:     }
237: 
238:     /**
239:      * Function is called in edit- and viewmode in order to generate teasercode
240:      * for output
241:      *
242:      * @param bool $returnAsArray modeswitch betwwen template generation and
243:      *        and returning result as array
244:      * @return mixed string of select box or array of articles
245:      */
246:     public function generateTeaserCode($returnAsArray = false) {
247:         global $contenido;
248: 
249:         $articles = array();
250: 
251:         $template = new cTemplate();
252:         // set title of teaser
253:         $template->set('s', 'TITLE', $this->_settings['teaser_title']);
254: 
255:         // decide if it is a manual or category teaser
256:         if ($this->_settings['teaser_manual'] == 'true' && count($this->_settings['teaser_manual_art']) > 0) {
257:             $manualArts = $this->_settings['teaser_manual_art'];
258:             if (!empty($manualArts) && !is_array($manualArts)) {
259:                 $manualArts = array(
260:                     $manualArts
261:                 );
262:             }
263:             if (is_array($manualArts)) {
264:                 $i = 0;
265:                 // in manual case get all art to display and generate article
266:                 // objects manually
267:                 foreach ($manualArts as $idArt) {
268:                     $article = new cApiArticleLanguage();
269:                     $article->loadByArticleAndLanguageId($idArt, $this->_lang);
270: 
271:                     // try to fill teaser image
272:                     if ($returnAsArray == false && $this->_fillTeaserTemplateEntry($article, $template)) {
273:                         $i++;
274:                         // break render, if teaser limit is reached
275:                         if ($i == $this->_settings['teaser_count']) {
276:                             break;
277:                         }
278:                     }
279: 
280:                     if ($returnAsArray == true && $this->_fillTeaserTemplateEntry($article, $template)) {
281:                         array_push($articles, $article);
282: 
283:                         if ($i == $this->_settings['teaser_count']) {
284:                             break;
285:                         }
286:                     }
287:                 }
288:             }
289:         } else {
290:             // in case of automatic teaser use class cArticleCollector
291:             // for getting all arts in category
292: 
293:             $options = array(
294:                 'lang' => $this->_lang,
295:                 'client' => $this->_client,
296:                 'idcat' => $this->_settings['teaser_category'],
297:                 'order' => $this->_settings['teaser_sort'],
298:                 'direction' => $this->_settings['teaser_sort_order'],
299:                 'limit' => $this->_settings['teaser_count'],
300:                 'start' => false,
301:                 'offline' => $contenido != ""
302:             );
303: 
304:             if ($this->_settings['teaser_start'] == 'true') {
305:                 $options['start'] = true;
306:             }
307: 
308:             $artCollector = new cArticleCollector($options);
309: 
310:             foreach ($artCollector as $article) {
311: 
312:                 $title =  trim($this->_getArtContent($article, $this->_settings['teaser_source_head'], $this->_settings['teaser_source_head_count']));
313:                 $text =  trim($this->_getArtContent($article, $this->_settings['teaser_source_text'], $this->_settings['teaser_source_text_count']));
314:                 $imageId = trim($this->_getArtContent($article, $this->_settings['teaser_source_image'], $this->_settings['teaser_source_image_count']));
315: 
316:                 if (!empty($title) || !empty($text) || !empty($imageId)) {
317:                     if ($returnAsArray == true) {
318:                         array_push($articles, $article);
319:                     } else {
320:                         $this->_fillTeaserTemplateEntry($article, $template);
321:                     }
322:                 }
323:             }
324:         }
325: 
326:         $code = '';
327: 
328:         // generate teasertemplate
329:         if ($returnAsArray == false && file_exists($this->_cfgClient[$this->_client]['path']['frontend'] . 'templates/' . $this->_settings['teaser_style']) && count($template->Dyn_replacements) > 0) {
330:             $code = $template->generate($this->_cfgClient[$this->_client]['path']['frontend'] . 'templates/' . $this->_settings['teaser_style'], true);
331:             return $code;
332:         } else if ($returnAsArray == true) {
333:             return $articles;
334:         }
335:     }
336: 
337:     /**
338:      * In edit and view mode this function fills teaser template with
339:      * informations from a CONTENIDO article object.
340:      *
341:      * @param cApiArticleLanguage $article - CONTENIDO Article object
342:      * @param cTemplate $template - CONTENIDO Template object (as reference)
343:      * @return boolean - success state of this operation
344:      */
345:     private function _fillTeaserTemplateEntry(cApiArticleLanguage $article, cTemplate &$template) {
346:         global $contenido;
347: 
348:         // get necessary informations for teaser from articles use properties in
349:         // a Settings for retrieval
350:         $title = $this->_getArtContent($article, $this->_settings['teaser_source_head'], $this->_settings['teaser_source_head_count']);
351:         $text = $this->_getArtContent($article, $this->_settings['teaser_source_text'], $this->_settings['teaser_source_text_count']);
352:         $imageId = $this->_getArtContent($article, $this->_settings['teaser_source_image'], $this->_settings['teaser_source_image_count']);
353:         $date = $this->_getArtContent($article, $this->_settings['teaser_source_date'], $this->_settings['teaser_source_date_count']);
354:         $idArt = $article->getField('idart');
355:         $published = $article->getField('published');
356:         $online = $article->getField('online');
357: 
358:         if ($online == 1 || $contenido) {
359:             // teaserfilter defines strings which must be contained in text for
360:             // display.
361:             // if string is defined check if article contains this string and
362:             // abort, if article does not contain this string
363:             if ($this->_settings['teaser_filter'] != '') {
364:                 $iPosText = strrpos(conHtmlEntityDecode($text), $this->_settings['teaser_filter']);
365:                 $iPosHead = strrpos(conHtmlEntityDecode($title), $this->_settings['teaser_filter']);
366:                 if (is_bool($iPosText) && !$iPosText && is_bool($iPosHead) && !$iPosHead) {
367:                     return false;
368:                 }
369:             }
370: 
371:             // convert date to readable format
372:             if (preg_match('/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/', $published, $results)) {
373:                 $published = $results[3] . '.' . $results[2] . '.' . $results[1];
374:             }
375: 
376:             // strip tags in teaser text and cut it if it is to long
377:             $title = trim(strip_tags($title));
378:             $text = trim(strip_tags($text));
379:             if (strlen($text) > $this->_settings['teaser_character_limit']) {
380:                 $text = capiStrTrimAfterWord($text, $this->_settings['teaser_character_limit']) . '...';
381:             }
382: 
383:             // try to get a teaser image directly from cms_img or try to extract
384:             // if a content type is given, wich contains html
385:             if ((int) $imageId > 0) {
386:                 $image = $this->_getImage($imageId, $this->_settings['teaser_image_width'], $this->_settings['teaser_image_height'], $this->_settings['teaser_image_crop']);
387:                 $template->set('d', 'IMAGE', $image['element']);
388:                 $template->set('d', 'IMAGE_SRC', $image['src']);
389:             } else if (strip_tags($imageId) != $imageId && strlen($imageId) > 0) {
390:                 $image = $this->_extractImage($imageId);
391:                 if (strlen($image) > 0) {
392:                     $template->set('d', 'IMAGE', $image['element']);
393:                     $template->set('d', 'IMAGE_SRC', $image['src']);
394:                 } else {
395:                     $template->set('d', 'IMAGE', '');
396:                     $template->set('d', 'IMAGE_SRC', '');
397:                 }
398:             } else {
399:                 $template->set('d', 'IMAGE_SRC', '');
400:                 $template->set('d', 'IMAGE', '');
401:             }
402: 
403:             // strip all tags from manual teaser date
404:             $date = strip_tags($date);
405: 
406:             // set generated values to teaser template
407:             $template->set('d', 'TITLE', $title);
408:             $template->set('d', 'TEXT', $text);
409: 
410:             $template->set('d', 'IDART', $idArt);
411:             $template->set('d', 'ART_URL', 'front_content.php?idart=' . $idArt);
412:             $template->set('d', 'PUBLISHED', $published);
413:             $template->set('d', 'PUBLISHED_MANUAL', $date);
414: 
415:             if ($date != '') {
416:                 $template->set('d', 'PUBLISHED_COMBINED', $date);
417:             } else {
418:                 $template->set('d', 'PUBLISHED_COMBINED', $published);
419:             }
420: 
421:             foreach (self::$_translations as $translationString) {
422:                 $template->set('d', $translationString, mi18n($translationString));
423:             }
424: 
425:             if ($this->iteration == 0) {
426:                 $template->set('d', 'ACTIVE', 'active');
427:             } else {
428:                 $template->set('d', 'ACTIVE', '');
429:             }
430:             $this->iteration++;
431: 
432:             $template->next();
433:         }
434: 
435:         return true;
436:     }
437: 
438:     /**
439:      * Teaser allows to get a list of ids in which article content is searched
440:      * in article like 1,2,5,6 the result with largest character count is
441:      * returned
442:      *
443:      * @param cApiArticleLanguage $article - CONTENIDO article object
444:      * @param string $contentTypeName - Name of Content type to extract
445:      *        informations from
446:      * @param string $ids - list of ids to search in
447:      * @return string - largest result of content
448:      */
449:     private function _getArtContent(cApiArticleLanguage &$article, $contentTypeName, $ids) {
450:         $this->_initCmsTypes();
451: 
452:         $return = '';
453:         // split ids, if there is only one id, array has only one place filled,
454:         // that is also ok
455:         foreach (explode(',', $ids) as $currentId) {
456:             if ($this->_forwardTypes[$contentTypeName] != "") {
457:                 $contentTypeName = $this->_forwardTypes[$contentTypeName];
458:             }
459:             $return .= ' ' . $article->getContent($contentTypeName, $currentId);
460:         }
461: 
462:         return $return;
463:     }
464: 
465:     /**
466:      * When a HTML Code is given for a Teaser image try to find a image in this
467:      * code and generate
468:      * Teaser image on that basis
469:      *
470:      * @param string $content - HTML string to search image in
471:      * @return string img tag containing scaled image
472:      */
473:     private function _extractImage($content) {
474:         $image = array();
475: 
476:         // search an image tag
477:         $regEx = "/<img[^>]*?>.*?/i";
478: 
479:         $match = array();
480:         preg_match($regEx, $content, $match);
481: 
482:         // if found extract its src content
483:         $regEx = "/(src)(=)(['\"]?)([^\"']*)(['\"]?)/i";
484:         $img = array();
485:         preg_match($regEx, $match[0], $img);
486: 
487:         // check if this image lies in upload folder
488:         $pos = strrpos($img[4], $this->_cfgClient[$this->_client]['upload']);
489:         if (!is_bool($pos)) {
490:             // if it is generate full internal path to image and scale it for
491:             // display using class internal function getImage()
492:             $file = $this->_cfgClient[$this->_client]['path']['frontend'] . $img[4];
493:             $image = $this->_getImage($file, $this->_settings['teaser_image_width'], $this->_settings['teaser_image_height'], $this->_settings['teaser_image_crop'], true);
494:         }
495: 
496:         return $image;
497:     }
498: 
499:     /**
500:      * Function gets path to an image of base of idupload in CONTENIDO,
501:      * scales this image on basis of teaser settings and returns path to
502:      * scaled image.
503:      * It is also possible to give path to image directly,
504:      * in this case set fourth parameter to true
505:      *
506:      * @param int $image - idupl of image to use for teaser
507:      * @param int $maxX - maximum image width
508:      * @param int $maxY - maximum image height
509:      * @param bool $isFile - in case of a direct file path retrival from
510:      *        database is not needed
511:      * @return string - <img> tag contains scaled image
512:      */
513:     private function _getImage($image, $maxX, $maxY, $cropped, $isFile = false) {
514:         $content = '';
515:         $return = array();
516: 
517:         if ($cropped == 'true') {
518:             $cropped = true;
519:         } else {
520:             $cropped = false;
521:         }
522: 
523:         // check if there is a need to get image path
524:         if ($isFile == false) {
525:             $upload = new cApiUpload($image);
526:             $dirname = $upload->get('dirname');
527:             $filename = $upload->get('filename');
528:             if (!empty($dirname) && !empty($filename)) {
529:                 $teaserImage = $this->_cfgClient[$this->_client]['path']['frontend'] . 'upload/' . $dirname . $filename;
530:             }
531:         } else {
532:             $teaserImage = $image;
533:         }
534: 
535:         // scale image if exists and return it
536:         if (file_exists($teaserImage)) {
537:             // Scale Image using cApiImgScale
538:             $imgSrc = cApiImgScale($teaserImage, $maxX, $maxY, $cropped);
539: 
540:             if ($this->_useXHTML == 'true') {
541:                 $letter = ' /';
542:             } else {
543:                 $letter = '';
544:             }
545: 
546:             // Put Image into the teasertext
547:             $content = '<img alt="" src="' . $imgSrc . '" class="teaser_image"' . $letter . '>' . $content;
548:         }
549: 
550:         $return['element'] = $content;
551:         $return['src'] = $imgSrc;
552: 
553:         return $return;
554:     }
555: 
556:     /**
557:      * Generates the code which should be shown if this content type is edited.
558:      *
559:      * @return string escaped HTML code which should be shown if content type is
560:      *         edited
561:      */
562:     public function generateEditCode() {
563:         $this->_initCmsTypes();
564: 
565:         $template = new cTemplate();
566:         // Set some values into javascript for a better handling
567:         $template->set('s', 'ID', $this->_id);
568:         $template->set('s', 'IDARTLANG', $this->_idArtLang);
569:         $template->set('s', 'FIELDS', "'" . implode("','", $this->_formFields) . "'");
570: 
571:         $templateTabs = new cTemplate();
572:         $templateTabs->set('s', 'PREFIX', $this->_prefix);
573: 
574:         // create code for general tab
575:         $templateTabs->set('d', 'TAB_ID', 'general');
576:         $templateTabs->set('d', 'TAB_CLASS', 'general');
577:         $templateTabs->set('d', 'TAB_CONTENT', $this->_generateTabGeneral());
578:         $templateTabs->next();
579: 
580:         // create code for advanced tab
581:         $templateTabs->set('d', 'TAB_ID', 'advanced');
582:         $templateTabs->set('d', 'TAB_CLASS', 'advanced');
583:         $templateTabs->set('d', 'TAB_CONTENT', $this->_generateTabAdvanced());
584:         $templateTabs->next();
585: 
586:         // create code for manual tab
587:         $templateTabs->set('d', 'TAB_ID', 'manual');
588:         $templateTabs->set('d', 'TAB_CLASS', 'manual');
589:         $templateTabs->set('d', 'TAB_CONTENT', $this->_generateTabManual());
590:         $templateTabs->next();
591: 
592:         $codeTabs = $templateTabs->generate($this->_cfg['path']['contenido'] . 'templates/standard/template.cms_abstract_tabbed_edit_tabs.html', true);
593: 
594:         // construct the top code of the template
595:         $templateTop = new cTemplate();
596:         $templateTop->set('s', 'ICON', 'images/isstart0.gif');
597:         $templateTop->set('s', 'ID', $this->_id);
598:         $templateTop->set('s', 'PREFIX', $this->_prefix);
599:         $templateTop->set('s', 'HEADLINE', i18n('Teaser settings'));
600:         $codeTop = $templateTop->generate($this->_cfg['path']['contenido'] . 'templates/standard/template.cms_abstract_tabbed_edit_top.html', true);
601: 
602:         // define the available tabs
603:         $tabMenu = array(
604:             'general' => i18n('Automatic'),
605:             'advanced' => i18n('Manual'),
606:             'manual' => i18n('Settings')
607:         );
608: 
609:         // construct the bottom code of the template
610:         $templateBottom = new cTemplate();
611:         $templateBottom->set('s', 'PATH_FRONTEND', $this->_cfgClient[$this->_client]['path']['htmlpath']);
612:         $templateBottom->set('s', 'ID', $this->_id);
613:         $templateBottom->set('s', 'PREFIX', $this->_prefix);
614:         $templateBottom->set('s', 'IDARTLANG', $this->_idArtLang);
615:         $templateBottom->set('s', 'FIELDS', "'" . implode("','", $this->_formFields) . "'");
616:         $templateBottom->set('s', 'SETTINGS', json_encode($this->_settings));
617:         $templateBottom->set('s', 'JS_CLASS_SCRIPT', $this->_cfg['path']['contenido_fullhtml'] . 'scripts/content_types/cmsTeaser.js');
618:         $templateBottom->set('s', 'JS_CLASS_NAME', 'Con.cContentTypeTeaser');
619:         $codeBottom = $templateBottom->generate($this->_cfg['path']['contenido'] . 'templates/standard/template.cms_abstract_tabbed_edit_bottom.html', true);
620: 
621:         // construct the whole template code
622:         $code = $this->generateViewCode();
623:         $code .= $this->_encodeForOutput($codeTop);
624:         $code .= $this->_generateTabMenuCode($tabMenu);
625:         $code .= $this->_encodeForOutput($codeTabs);
626:         $code .= $this->_generateActionCode();
627:         $code .= $this->_encodeForOutput($codeBottom);
628: 
629:         return $code;
630:     }
631: 
632:     /**
633:      * Gets all currenty avariable content types and their ids
634:      * from database and store it into class variable aCMSTypes.
635:      * Because this information is used multiple times, this causes a better
636:      * performance than gettting it seperately
637:      */
638:     private function _initCmsTypes() {
639:         if (!empty($this->_cmsTypes)) {
640:             return;
641:         }
642: 
643:         $this->_cmsTypes = array();
644: 
645:         $sql = 'SELECT * FROM ' . $this->_cfg['tab']['type'] . ' ORDER BY type';
646:         $db = cRegistry::getDb();
647:         $db->query($sql);
648:         while ($db->nextRecord()) {
649:             // we do not want certain content types
650:             if (in_array($db->f('type'), $this->_ignoreTypes)) {
651:                 continue;
652:             }
653:             $this->_cmsTypes[$db->f('idtype')] = $db->f('type');
654:         }
655:     }
656: 
657:     /**
658:      * Generates code for the general tab in which various settings can be made.
659:      *
660:      * @return string - the code for the general tab
661:      */
662:     private function _generateTabGeneral() {
663:         // define a wrapper which contains the whole content of the general tab
664:         $wrapper = new cHTMLDiv();
665:         $wrapperContent = array();
666: 
667:         // $wrapperContent[] = new cHTMLParagraph(i18n('General settings'),
668:         // 'head_sub');
669:         $wrapperContent[] = new cHTMLLabel(i18n('Teaser title'), 'teaser_title_' . $this->_id);
670:         $wrapperContent[] = new cHTMLTextbox('teaser_title_' . $this->_id, $this->_settings['teaser_title'], '', '', 'teaser_title_' . $this->_id);
671:         $wrapperContent[] = new cHTMLLabel(i18n('Source category'), 'teaser_category_' . $this->_id);
672:         $wrapperContent[] = buildCategorySelect('teaser_category_' . $this->_id, $this->_settings['teaser_category'], 0);
673:         $wrapperContent[] = new cHTMLLabel(i18n('Number of articles'), 'teaser_count_' . $this->_id);
674:         $wrapperContent[] = $this->_generateCountSelect();
675: 
676:         $wrapperContent[] = new cHTMLLabel(i18n("Include start article"), 'teaser_start_' . $this->_id);
677:         $wrapperContent[] = new cHTMLCheckbox('teaser_start_' . $this->_id, '', 'teaser_start_' . $this->_id, ($this->_settings['teaser_start'] == 'true'));
678: 
679:         $wrapperContent[] = new cHTMLLabel(i18n("Teaser sort"), 'teaser_sort_' . $this->_id);
680:         $wrapperContent[] = $this->_generateSortSelect();
681:         $wrapperContent[] = new cHTMLLabel(i18n("Sort order"), 'teaser_sort_order_' . $this->_id);
682:         $wrapperContent[] = $this->_generateSortOrderSelect();
683: 
684:         $wrapper->setContent($wrapperContent);
685:         return $wrapper->render();
686:     }
687: 
688:     /**
689:      * Generats a select box for setting number of articles which should be
690:      * displayed in teaser as a maximum.
691:      * Only important in editmode.
692:      *
693:      * @return string html string of select box
694:      */
695:     private function _generateCountSelect() {
696:         $htmlSelect = new cHTMLSelectElement('teaser_count_' . $this->_id, '', 'teaser_count_' . $this->_id);
697: 
698:         // set please chose option element
699:         $htmlSelectOption = new cHTMLOptionElement(i18n('Please choose'), '', true);
700:         $htmlSelect->appendOptionElement($htmlSelectOption);
701: 
702:         // generate a select box containing count 1 to 20 for maximum teaser
703:         // count
704:         for ($i = 1; $i <= 20; $i++) {
705:             $htmlSelectOption = new cHTMLOptionElement($i, $i, false);
706:             $htmlSelect->appendOptionElement($htmlSelectOption);
707:         }
708: 
709:         // set default value
710:         $htmlSelect->setDefault($this->_settings['teaser_count']);
711: 
712:         return $htmlSelect->render();
713:     }
714: 
715:     /**
716:      * Generats a select box for setting teaser style
717:      * currently two seperate teaser templates were supported
718:      *
719:      * @return html string of select box
720:      */
721:     private function _generateStyleSelect() {
722:         $htmlSelect = new cHTMLSelectElement('teaser_style_' . $this->_id, '', 'teaser_style_' . $this->_id);
723: 
724:         // set please chose option element
725:         $htmlSelectOption = new cHTMLOptionElement(i18n("Please choose"), '', true);
726:         $htmlSelect->appendOptionElement($htmlSelectOption);
727: 
728:         // set other avariable options manually
729:         $htmlSelectOption = new cHTMLOptionElement(i18n("Slider style"), 'cms_teaser_slider.html', false);
730:         $htmlSelect->appendOptionElement($htmlSelectOption);
731: 
732:         $htmlSelectOption = new cHTMLOptionElement(i18n("Image style"), 'cms_teaser_image.html', false);
733:         $htmlSelect->appendOptionElement($htmlSelectOption);
734: 
735:         $htmlSelectOption = new cHTMLOptionElement(i18n("Text style"), 'cms_teaser_text.html', false);
736:         $htmlSelect->appendOptionElement($htmlSelectOption);
737: 
738:         $htmlSelectOption = new cHTMLOptionElement(i18n("Blog style"), 'cms_teaser_blog.html', false);
739:         $htmlSelect->appendOptionElement($htmlSelectOption);
740: 
741:         $additionalOptions = getEffectiveSettingsByType('cms_teaser');
742:         foreach ($additionalOptions as $sLabel => $sTemplate) {
743:             $htmlSelectOption = new cHTMLOptionElement($sLabel, $sTemplate, false);
744:             $htmlSelect->appendOptionElement($htmlSelectOption);
745:         }
746: 
747:         // set default value
748:         $htmlSelect->setDefault($this->_settings['teaser_style']);
749: 
750:         return $htmlSelect->render();
751:     }
752: 
753:     /**
754:      * Teaser gets informations from other articles and their content typs
755:      * Function builds a select box in which coresponding cms type can be
756:      * selected
757:      * after that a text box is rendered for setting id for this conent type to
758:      * get
759:      * informations from.
760:      * This function is used three times for source defintion of
761:      * headline text and teaserimage
762:      *
763:      * @param string $selectName - name of input elements
764:      * @param string $selected - value of select box which is selected
765:      * @param string $value - current value of text box
766:      * @return string html string of select box
767:      */
768:     private function _generateTypeSelect($selectName, $selected, $value) {
769:         // make sure that the ID is at the end of the form field name
770:         $inputName = str_replace('_' . $this->_id, '_count_' . $this->_id, $selectName);
771:         // generate textbox for content type id
772:         $htmlInput = new cHTMLTextbox($inputName, $value, '', '', $inputName, false, '', '', 'teaser_type_count');
773: 
774:         // generate content type select
775:         $htmlSelect = new cHTMLSelectElement($selectName, '', $selectName);
776:         $htmlSelect->setClass('teaser_type_select');
777: 
778:         $htmlSelectOption = new cHTMLOptionElement(i18n("Please choose"), '', true);
779:         $htmlSelect->addOptionElement(0, $htmlSelectOption);
780: 
781:         // use $this->_cmsTypes as basis for this select box which contains all
782:         // avariable content types in system
783:         foreach ($this->_cmsTypes as $key => $value) {
784:             $htmlSelectOption = new cHTMLOptionElement($value, $value, false);
785:             $htmlSelect->addOptionElement($key, $htmlSelectOption);
786:         }
787: 
788:         // set default value
789:         $htmlSelect->setDefault($selected);
790: 
791:         return $htmlSelect->render() . $htmlInput->render();
792:     }
793: 
794:     /**
795:      * Generates code for the advanced tab in which various advanced settings
796:      * can be made.
797:      *
798:      * @return string - the code for the advanced tab
799:      */
800:     private function _generateTabAdvanced() {
801:         // define a wrapper which contains the whole content of the advanced tab
802:         $wrapper = new cHTMLDiv();
803:         $wrapperContent = array();
804: 
805:         // $wrapperContent[] = new cHTMLParagraph(i18n('Manual teaser
806:         // settings'), 'head_sub');
807:         $wrapperContent[] = new cHTMLLabel(i18n('Manual teaser'), 'teaser_manual_' . $this->_id);
808:         $wrapperContent[] = new cHTMLCheckbox('teaser_manual_' . $this->_id, '', 'teaser_manual_' . $this->_id, ($this->_settings['teaser_manual'] == 'true'));
809: 
810:         // $wrapperContent[] = new cHTMLParagraph(i18n('Add article'),
811:         // 'head_sub');
812:         $wrapperContent[] = new cHTMLLabel(i18n('Category'), 'teaser_cat_' . $this->_id);
813:         $wrapperContent[] = buildCategorySelect('teaser_cat_' . $this->_id, 0, 0);
814:         $wrapperContent[] = new cHTMLLabel(i18n('Article'), 'teaser_art_' . $this->_id);
815:         $wrapperContent[] = buildArticleSelect('teaser_art_' . $this->_id, 0, 0);
816: 
817:         $wrapperContent[] = new cHTMLLabel(i18n('Add'), 'add_art_' . $this->_id);
818:         $image = new cHTMLImage($this->_cfg['path']['contenido_fullhtml'] . 'images/but_art_new.gif');
819:         $image->setAttribute('id', 'add_art_' . $this->_id);
820:         $image->appendStyleDefinition('cursor', 'pointer');
821:         $wrapperContent[] = $image;
822: 
823:         $wrapperContent[] = new cHTMLParagraph(i18n('Included articles'), 'head_sub');
824:         $selectElement = new cHTMLSelectElement('teaser_manual_art_' . $this->_id, '', 'teaser_manual_art_' . $this->_id, false, '', '', 'manual');
825:         $selectElement->setAttribute('size', '4');
826:         $selectElement->setAttribute('multiple', 'multiple');
827:         // there can be one or multiple selected articles
828:         if (is_array($this->_settings['teaser_manual_art'])) {
829:             foreach ($this->_settings['teaser_manual_art'] as $index => $idArt) {
830:                 $option = new cHTMLOptionElement($this->_getArtName($idArt), $idArt, true);
831:                 $selectElement->addOptionElement($index, $option);
832:             }
833:         } else {
834:             // check if the article really exists
835:             $artName = $this->_getArtName($this->_settings['teaser_manual_art']);
836:             if ($artName != i18n('Unknown article')) {
837:                 $option = new cHTMLOptionElement($artName, $this->_settings['teaser_manual_art'], true);
838:                 $selectElement->addOptionElement(0, $option);
839:             }
840:         }
841:         $wrapperContent[] = $selectElement;
842: 
843:         $wrapperContent[] = new cHTMLLabel(i18n("Delete"), 'del_art_' . $this->_id);
844:         $image = new cHTMLImage($this->_cfg['path']['contenido_fullhtml'] . 'images/delete.gif');
845:         $image->setAttribute('id', 'del_art_' . $this->_id);
846:         $image->appendStyleDefinition('cursor', 'pointer');
847:         $wrapperContent[] = $image;
848: 
849:         $wrapper->setContent($wrapperContent);
850:         return $wrapper->render();
851:     }
852: 
853:     /**
854:      * Function which generated a select box for setting teaser
855:      * sort argument
856:      *
857:      * @return string html string of select box
858:      */
859:     private function _generateSortSelect() {
860:         $htmlSelect = new cHTMLSelectElement('teaser_sort_' . $this->_id, '', 'teaser_sort_' . $this->_id);
861: 
862:         // set please chose option element
863:         $htmlSelectOption = new cHTMLOptionElement(i18n("Please choose"), '', true);
864:         $htmlSelect->appendOptionElement($htmlSelectOption);
865: 
866:         // set other avariable options manually
867:         $htmlSelectOption = new cHTMLOptionElement(i18n("Sort sequence"), 'sortsequence', false);
868:         $htmlSelect->appendOptionElement($htmlSelectOption);
869: 
870:         $htmlSelectOption = new cHTMLOptionElement(i18n("Creation date"), 'creationdate', false);
871:         $htmlSelect->appendOptionElement($htmlSelectOption);
872: 
873:         $htmlSelectOption = new cHTMLOptionElement(i18n("Published date"), 'publisheddate', false);
874:         $htmlSelect->appendOptionElement($htmlSelectOption);
875: 
876:         $htmlSelectOption = new cHTMLOptionElement(i18n("Modification date"), 'modificationdate', false);
877:         $htmlSelect->appendOptionElement($htmlSelectOption);
878: 
879:         // set default value
880:         $htmlSelect->setDefault($this->_settings['teaser_sort']);
881: 
882:         return $htmlSelect->render();
883:     }
884: 
885:     /**
886:      * Function which generated a select box for setting teaser
887:      * sort order argument
888:      *
889:      * @return string html string of select box
890:      */
891:     private function _generateSortOrderSelect() {
892:         $htmlSelect = new cHTMLSelectElement('teaser_sort_order_' . $this->_id, '', 'teaser_sort_order_' . $this->_id);
893: 
894:         // set please chose option element
895:         $htmlSelectOption = new cHTMLOptionElement(i18n("Please choose"), '', true);
896:         $htmlSelect->appendOptionElement($htmlSelectOption);
897: 
898:         // set other avariable options manually
899:         $htmlSelectOption = new cHTMLOptionElement(i18n("Ascending"), 'asc', false);
900:         $htmlSelect->appendOptionElement($htmlSelectOption);
901: 
902:         $htmlSelectOption = new cHTMLOptionElement(i18n("Descending"), 'desc', false);
903:         $htmlSelect->appendOptionElement($htmlSelectOption);
904: 
905:         // set default value
906:         $htmlSelect->setDefault($this->_settings['teaser_sort_order']);
907: 
908:         return $htmlSelect->render();
909:     }
910: 
911:     /**
912:      * Function which provides select option for cropping teaser images
913:      *
914:      * @return string html string of select box
915:      */
916:     private function _generateCropSelect() {
917:         $htmlSelect = new cHTMLSelectElement('teaser_image_crop_' . $this->_id, '', 'teaser_image_crop_' . $this->_id);
918: 
919:         // set please chose option element
920:         $htmlSelectOption = new cHTMLOptionElement(i18n("Please choose"), '', true);
921:         $htmlSelect->appendOptionElement($htmlSelectOption);
922: 
923:         // set other avariable options manually
924:         $htmlSelectOption = new cHTMLOptionElement(i18n("Scaled"), 'false', false);
925:         $htmlSelect->appendOptionElement($htmlSelectOption);
926: 
927:         $htmlSelectOption = new cHTMLOptionElement(i18n("Cropped"), 'true', false);
928:         $htmlSelect->appendOptionElement($htmlSelectOption);
929: 
930:         // set default value
931:         $htmlSelect->setDefault($this->_settings['teaser_image_crop']);
932: 
933:         return $htmlSelect->render();
934:     }
935: 
936:     /**
937:      * Generates code for the manual tab in which various settings for the
938:      * manual teaser can be made.
939:      *
940:      * @return string - the code for the manual tab
941:      */
942:     private function _generateTabManual() {
943:         // define a wrapper which contains the whole content of the manual tab
944:         $wrapper = new cHTMLDiv();
945:         $wrapperContent = array();
946: 
947:         $wrapperContent[] = new cHTMLParagraph(i18n("Content visualisation"), 'head_sub');
948:         $wrapperContent[] = new cHTMLLabel(i18n("Teaser visualisation"), 'teaser_style');
949:         $wrapperContent[] = $this->_generateStyleSelect();
950:         $wrapperContent[] = new cHTMLLabel(i18n("Teaser filter"), 'teaser_filter_' . $this->_id);
951:         $wrapperContent[] = new cHTMLTextbox('teaser_filter_' . $this->_id, $this->_settings['teaser_filter'], '', '', 'teaser_filter_' . $this->_id);
952:         $wrapperContent[] = new cHTMLLabel(i18n('Character length'), 'teaser_character_limit_' . $this->_id);
953:         $wrapperContent[] = new cHTMLTextbox('teaser_character_limit_' . $this->_id, $this->_settings['teaser_character_limit'], '', '', 'teaser_character_limit_' . $this->_id);
954: 
955:         $wrapperContent[] = new cHTMLParagraph(i18n("Pictures"), 'head_sub');
956:         $wrapperContent[] = new cHTMLLabel(i18n('Image width'), 'teaser_image_width_' . $this->_id);
957:         $wrapperContent[] = new cHTMLTextbox('teaser_image_width_' . $this->_id, $this->_settings['teaser_image_width'], '', '', 'teaser_image_width_' . $this->_id);
958:         $wrapperContent[] = new cHTMLLabel(i18n('Image height'), 'teaser_image_height_' . $this->_id);
959:         $wrapperContent[] = new cHTMLTextbox('teaser_image_height_' . $this->_id, $this->_settings['teaser_image_height'], '', '', 'teaser_image_height_' . $this->_id);
960:         $wrapperContent[] = new cHTMLLabel(i18n('Image scale'), 'teaser_image_crop_' . $this->_id);
961:         $wrapperContent[] = $this->_generateCropSelect();
962: 
963:         $wrapperContent[] = new cHTMLParagraph(i18n("Content types"), 'head_sub');
964:         $wrapperContent[] = new cHTMLLabel(i18n("Headline source"), 'teaser_source_head_' . $this->_id);
965:         $wrapperContent[] = $this->_generateTypeSelect('teaser_source_head_' . $this->_id, $this->_settings['teaser_source_head'], $this->_settings['teaser_source_head_count']);
966:         $wrapperContent[] = new cHTMLLabel(i18n("Text source"), 'teaser_source_text_' . $this->_id);
967:         $wrapperContent[] = $this->_generateTypeSelect('teaser_source_text_' . $this->_id, $this->_settings['teaser_source_text'], $this->_settings['teaser_source_text_count']);
968:         $wrapperContent[] = new cHTMLLabel(i18n('Image source'), 'teaser_source_image_' . $this->_id);
969:         $wrapperContent[] = $this->_generateTypeSelect('teaser_source_image_' . $this->_id, $this->_settings['teaser_source_image'], $this->_settings['teaser_source_image_count']);
970:         $wrapperContent[] = new cHTMLLabel(i18n('Date source'), 'teaser_source_date_' . $this->_id);
971:         $wrapperContent[] = $this->_generateTypeSelect('teaser_source_date_' . $this->_id, $this->_settings['teaser_source_date'], $this->_settings['teaser_source_date_count']);
972: 
973:         $wrapper->setContent($wrapperContent);
974:         return $wrapper->render();
975:     }
976: 
977:     /**
978:      * Function retrives name of an article by its id from database
979:      *
980:      * @param int $idArt - CONTENIDO article id
981:      * @return string - name of article
982:      */
983:     private function _getArtName($idArt) {
984:         $article = new cApiArticleLanguage();
985:         $article->loadByArticleAndLanguageId((int) $idArt, $this->_lang);
986: 
987:         $title = $article->get('title');
988:         if ($article->isLoaded() && !empty($title)) {
989:             return $article->get('title');
990:         } else {
991:             return i18n('Unknown article');
992:         }
993:     }
994: 
995: }