Creates the month flydown for this date entry

@return SwatFlydown the month flydown for this date entry.
357236
protected function createMonthFlydown()
    {
        $flydown = new SwatFlydown($this->id . '_month');
        $flydown->classes = array('swat-date-entry-month');

        if ($this->show_blank_titles) {
            $flydown->blank_title = $this->getMonthBlankValueTitle();
        }

        $range_end = clone $this->valid_range_end;
        $difference = $this->valid_range_start->diff($range_end);

        // Subtract a second from the end date. This makes comparison correct,
        // and prevents displaying extra months. The difference needs to happen
        // before this to prevent December specific bugs.
        $range_end->subtractSeconds(1);

        $start_year = $this->valid_range_start->getYear();
        $end_year = $range_end->getYear();
        $start_month = $this->valid_range_start->getMonth();
        $end_month = $range_end->getMonth();

        if ($end_year == $start_year) {
            // if the years match, only display the valid months.
            for ($i = $start_month; $i <= $end_month; $i++) {
                $flydown->addOption($i, $this->getMonthOptionText($i));
            }
        } else {
            for ($i = 1; $i <= 12; $i++) {
                $flydown->addOption($i, $this->getMonthOptionText($i));
            }
        }

        return $flydown;
    }
799534
public final function setMonth( int $month = null )
      : DateTime
   {

      if ( \is_null( $month ) )
      {
         $month = static::CurrentMonth();
      }

      return $this->setDateParts( null, $month );

   }
268481
protected function &getOptions()
    {
        $options = array();

        // If the parent flydown is empty, set parent_value to a blank string.
        // This will then return any options that exist for a blank parent.
        $parent_value = $this->hasEmptyParent() ? '' : $this->getParentValue();

        // parent_value is null when the parent has multiple options
        if ($parent_value === null) {
            if ($this->cascade_from->show_blank) {
                // select the blank option on the cascade from
                $options = array(
                    new SwatOption('', '&nbsp;'),
                    new SwatOption('', '&nbsp;')
                );
            } else {
                // select the first option on the cascade from
                $from_options = $this->cascade_from->getOptions();
                $first_value = reset($from_options)->value;
                $options = $this->options[$first_value];
            }
        } elseif (isset($this->options[$parent_value])) {
            $options = $this->options[$parent_value];
        } else {
            // if the options array doesn't exist for this parent_value, then
            // assume that means we don't want any values in this flydown for
            // that option.
            $options = array(new SwatOption(null, null));
        }

        return $options;
    }
543600
public boolean addCreationDate() {
        try {
			/* bugfix by 'taqua' (Thomas) */
			final SimpleDateFormat sdf = new SimpleDateFormat(
					"EEE MMM dd HH:mm:ss zzz yyyy");
			return add(new Meta(Element.CREATIONDATE, sdf.format(new Date())));
		} catch (DocumentException de) {
            throw new ExceptionConverter(de);
        }
    }
1115767
public CalendarMonth plus(Months months) {

        if (months.isEmpty()) {
            return this;
        }

        long value = this.year * 12L + this.month.getValue() - 1 + months.getAmount();
        int y = MathUtils.safeCast(MathUtils.floorDivide(value, 12));
        Month m = Month.valueOf(MathUtils.floorModulo(value, 12) + 1);
        return CalendarMonth.of(y, m);

    }
783580
protected function getThisMonth() {
        if (!$this->_thisMonth) {
            $this->_thisMonth = new ThisMonthList($this->version, $this->solution['accountSid']);
        }

        return $this->_thisMonth;
    }
384283
public static <D extends Comparable> DateTimeExpression<D> addMonths(DateTimeExpression<D> date, int months) {
        return Expressions.dateTimeOperation(date.getType(), Ops.DateTimeOps.ADD_MONTHS, date, ConstantImpl.create(months));
    }
846774
protected function getBlankOption()
    {
        $blank_title =
            $this->blank_title === null
                ? Swat::_('choose one ...')
                : $this->blank_title;

        return new SwatFlydownBlankOption(null, $blank_title);
    }
349866
public static Month toMonth(final Calendar self) {
        return Month.of(self.get(Calendar.MONTH) + 1);
    }
1255502
public function withMonth(int $month) : ZonedDateTime
    {
        return ZonedDateTime::of($this->localDateTime->withMonth($month), $this->timeZone);
    }
244156
function(month) {
        var cfgPageDate = DEF_CFG.PAGEDATE.key,
            current = this.cfg.getProperty(cfgPageDate);
        current.setMonth(parseInt(month, 10));
        this.cfg.setProperty(cfgPageDate, current);
    }
211479
public function display()
    {
        if (!$this->visible) {
            return;
        }

        parent::display();

        $div_tag = new SwatHtmlTag('div');
        $div_tag->id = $this->id;
        $div_tag->class = $this->getCSSClassString();
        $div_tag->open();

        echo '<span class="swat-date-entry-span">';

        foreach ($this->getDatePartOrder() as $datepart) {
            if ($datepart == 'd' && $this->display_parts & self::DAY) {
                $day_flydown = $this->getCompositeWidget('day_flydown');

                if ($day_flydown->value === null && $this->value !== null) {
                    $day_flydown->value = $this->value->getDay();
                }

                $day_flydown->display();
            } elseif ($datepart == 'm' && $this->display_parts & self::MONTH) {
                $month_flydown = $this->getCompositeWidget('month_flydown');

                if ($month_flydown->value === null && $this->value !== null) {
                    $month_flydown->value = $this->value->getMonth();
                }

                $month_flydown->display();
            } elseif ($datepart == 'y' && $this->display_parts & self::YEAR) {
                $year_flydown = $this->getCompositeWidget('year_flydown');

                if ($year_flydown->value === null && $this->value !== null) {
                    $year_flydown->value = $this->value->getYear();
                }

                $year_flydown->display();
            }
        }

        echo '</span>';

        if ($this->display_parts & self::CALENDAR) {
            $calendar = $this->getCompositeWidget('calendar');
            $calendar->display();
        }

        if ($this->display_parts & self::TIME) {
            $time_entry = $this->getCompositeWidget('time_entry');

            // if we aren't using the current date then we won't use the
            // current time
            if (!$this->use_current_date) {
                $time_entry->use_current_time = false;
            }

            echo ' ';
            if ($time_entry->value === null && $this->value !== null) {
                $time_entry->value = $this->value;
            }

            $time_entry->display();
        }

        Swat::displayInlineJavaScript($this->getInlineJavaScript());

        $div_tag->close();
    }
419913
function getCalendar() {
            if (this.clazz.$name === undefined) {
                throw new Error();
            }

            if (this.calendar === undefined || this.calendar === null) {
                var $this = this;

                this.$freezeCalendar = false;

                this.calendar = new pkg.Calendar([
                    function $clazz() {
                        this.MonthsCombo.$name = "INNER";
                    },

                    function winActivated(e) {
                        if (e.isActive === false) {
                            $this.hideCalendar();
                        }
                    },

                    function childKeyPressed(e){
                        if (e.code === "Escape") {
                            $this.hideCalendar();
                        }
                    },

                    function dateSelected(date, b) {
                        this.$super(date, b);
                        if (date !== null && b) {
                            if ($this.$freezeCalendar === false) {
                                if ($this.dateSelected !== undefined) {
                                    $this.dateSelected.call($this, date, b);
                                }
                                $this.hideCalendar();
                            }
                        }
                    }
                ]);
            }
            return this.calendar;
        }
841331
@Nonnull
  public CalendarIntervalTrigger build ()
  {
    final CalendarIntervalTrigger st = new CalendarIntervalTrigger ();
    st.setRepeatInterval (m_nInterval);
    st.setRepeatIntervalUnit (m_eIntervalUnit);
    st.setMisfireInstruction (m_nMisfireInstruction);
    st.setTimeZone (m_aTimeZone);
    st.setPreserveHourOfDayAcrossDaylightSavings (m_bPreserveHourOfDayAcrossDaylightSavings);
    st.setSkipDayIfHourDoesNotExist (m_bSkipDayIfHourDoesNotExist);
    return st;
  }
113268
protected function _monthSelect($options, $context)
    {
        $options += [
            'name' => '',
            'names' => false,
            'val' => null,
            'leadingZeroKey' => true,
            'leadingZeroValue' => false,
            'templateVars' => [],
        ];

        if (empty($options['options'])) {
            if ($options['names'] === true) {
                $options['options'] = $this->_getMonthNames($options['leadingZeroKey']);
            } elseif (is_array($options['names'])) {
                $options['options'] = $options['names'];
            } else {
                $options['options'] = $this->_generateNumbers(1, 12, $options);
            }
        }

        unset($options['leadingZeroKey'], $options['leadingZeroValue'], $options['names']);

        return $this->_select->render($options, $context);
    }
658861
public static java.sql.Timestamp monthBegin() {
		Calendar mth = Calendar.getInstance();

		mth.set(Calendar.DAY_OF_MONTH, 1);
		mth.set(Calendar.HOUR_OF_DAY, 0);
		mth.set(Calendar.MINUTE, 0);
		mth.set(Calendar.SECOND, 0);
		mth.set(Calendar.AM_PM, Calendar.AM);
		return new java.sql.Timestamp(mth.getTime().getTime());
	}
240053
public function monthly()
    {
        $this->setScheduleMonth(self::ANY);
        $this->setScheduleWeek(self::NONE);
        $this->setScheduleDayOfMonth(1);
        $this->setScheduleDayOfWeek(self::ANY);
        $this->setScheduleHour(0);
        $this->setScheduleMinute(0);

        return $this;
    }