예제 #1
0
    def __init__(self, parent):
        super().__init__(parent)
        layout = QFormLayout(self)
        self.setWindowTitle("Enter New Record")
        only_int = QIntValidator(self)
        only_int.setTop(999999)
        self._ap_phase_id_entry = QLineEdit(self)
        self._ap_phase_id_entry.setPlaceholderText("e.g. 212421")
        self._ap_phase_id_entry.setValidator(only_int)
        self._address_entry = QLineEdit(self)
        self._address_entry.setPlaceholderText("1234 Sample Ave")
        button_row = QWidget(self)
        button_layout = QHBoxLayout(button_row)
        self._enter_button = QPushButton("Enter")
        self._enter_button.clicked.connect(self.enter)
        self._cancel_button = QPushButton("Cancel")
        self._canceled = True 
        self._cancel_button.clicked.connect(self.close) 

        button_layout.addWidget(self._enter_button)
        button_layout.addWidget(self._cancel_button) 
        layout.addRow(QLabel("Enter the ApPhase ID and Address:\n(the ApPhase ID must 6 numbers, neither field can be blank.)\n", self))
        layout.addRow("ApPhase ID:", self._ap_phase_id_entry)
        layout.addRow("Address:", self._address_entry)
        layout.addRow(button_row)
예제 #2
0
 def setEvaluationArea(self):
     form_box = FormGroupBox("Evaluation", self)
     #form_box = FormBox("Evaluation", self)
     only_int = QIntValidator(self)
     only_int.setTop(999999)
     Client.AP_PHASE_ID.value.setValidator(only_int)
     form_box.frame_layout.addRow("ApPhase ID:", Client.AP_PHASE_ID.value)
     form_box.frame_layout.addRow("Date:", Client.DATE.value)
     form_box.frame_layout.addRow("Address:", Client.ADDRESS.value)
     self._scroll_layout.addRow(form_box)
예제 #3
0
class Cal(QWidget):

    HS = "甲乙丙丁戊己庚辛壬癸"
    EB = "子丑寅卯辰巳午未申酉戌亥"
    ZD = "鼠牛虎兔龙蛇马羊猴鸡狗猪"

    def __init__(self, admin):
        super(Cal, self).__init__()

        self.ui = Ui_Form()

        self.ui.setupUi(self)

        self.clock = AnalogClock(self)
        self.clock.setFixedWidth(200)
        self.clock.setFixedHeight(200)
        self.clock.setObjectName('clock')
        self.ui.horizontalLayout_4.addWidget(self.clock)

        self.lock()

        self._datetime = datetime.now()

        self.updateDatetime()

        self.timer_id = self.startTimer(1000)

        self.admin = admin

        self.editing = False
        if admin:
            self.ui.edit_button.clicked.connect(self.onEditButtonClicked)
            self.ui.fix_button.clicked.connect(self.onFixButtonClicked)
        else:
            self.ui.edit_button.setDisabled(True)
            self.ui.fix_button.setDisabled(True)

        self.year_validator = QIntValidator(0, 99999, self)
        self.month_validator = QIntValidator(1, 12, self)
        self.day_validator = QIntValidator(1, 30, self)
        self.setDayValidator()

        self.hour_validator = QIntValidator(0, 23, self)
        self.time_validator = QIntValidator(0, 59, self)

        self.ui.year_edit.setValidator(self.year_validator)
        self.ui.month_edit.setValidator(self.month_validator)
        self.ui.day_edit.setValidator(self.day_validator)

        self.ui.hour_edit.setValidator(self.hour_validator)
        self.ui.minute_edit.setValidator(self.time_validator)
        self.ui.second_edit.setValidator(self.time_validator)

        self.ui.year_edit.textChanged.connect(self.onYearChanged)
        self.ui.month_edit.textChanged.connect(self.onMonthChanged)
        self.ui.day_edit.textChanged.connect(self.onDayChanged)

        self.ui.hour_edit.textChanged.connect(self.onHourChanged)
        self.ui.minute_edit.textChanged.connect(self.onMinuteChanged)
        self.ui.second_edit.textChanged.connect(self.onSecondChanged)

    # lock lineEdit
    def lock(self):
        self.ui.year_edit.setReadOnly(True)
        self.ui.month_edit.setReadOnly(True)
        self.ui.day_edit.setReadOnly(True)

        self.ui.hour_edit.setReadOnly(True)
        self.ui.minute_edit.setReadOnly(True)
        self.ui.second_edit.setReadOnly(True)

    # unlock lineEdit
    def unlock(self):
        self.ui.year_edit.setReadOnly(False)
        self.ui.month_edit.setReadOnly(False)
        self.ui.day_edit.setReadOnly(False)

        self.ui.hour_edit.setReadOnly(False)
        self.ui.minute_edit.setReadOnly(False)
        self.ui.second_edit.setReadOnly(False)

    @property
    def time(self):
        return self._datetime

    @time.setter
    def time(self, dtime: datetime):
        self._datetime = dtime
        self.updateDatetime()

    def isLeapYear(self):
        year = self._datetime.year
        if year % 100 == 0 and year % 400 != 0:
            return False, "平年"
        elif year % 4 != 0:
            return False, "平年"
        return True, "闰年"

    def calcInfo(self):
        # 天干
        hs = self.HS[(self._datetime.year - 4) % 10]
        # 地支
        eb = self.EB[(self._datetime.year - 4) % 12]
        # 属相
        zd = self.ZD[(self._datetime.year - 4) % 12]
        self.ui.lbl_info.setText("{}{}{}年 {}".format(hs, eb, zd,
                                                     self.isLeapYear()[1]))

    def dt2t(self, dtime: datetime):
        tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst = time.gmtime(
            dtime.timestamp())
        return tm_year, tm_mon, tm_wday, tm_mday, tm_hour, tm_min, tm_sec, 0

    def ts2t(self, timestamp: int):
        tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst = time.gmtime(
            timestamp)
        return tm_year, tm_mon, tm_wday, tm_mday, tm_hour, tm_min, tm_sec, 0

    def onFixButtonClicked(self):
        try:
            c = ntplib.NTPClient()
            res = c.request('pool.ntp.org')
            win32api.SetSystemTime(*self.ts2t(res.tx_time))
            if self.editing:
                self.ui.edit_button.click()
        except:
            pass

    def onEditButtonClicked(self):
        self.editing = not self.editing
        self.ui.edit_button.setStyleSheet(
            "background: rgb(0, 0, 233); color: rgb(255, 255, 255)" if self.
            editing else "")
        if self.editing:
            self.unlock()
            try:
                win32api.SetSystemTime(*self.dt2t(self._datetime))
            except:
                # set failed
                self.editing = False
                self.ui.edit_button.setStyleSheet("")
                self.lock()
        else:
            self.lock()

    def setDayValidator(self):
        month = self._datetime.month
        if month == 2:
            if self.isLeapYear()[0]:
                self.day_validator.setTop(29)
            else:
                self.day_validator.setTop(28)
        elif month in [1, 3, 5, 7, 8, 10, 12]:
            self.day_validator.setTop(31)
        else:
            self.day_validator.setTop(30)

    def onYearChanged(self, year):
        if not self.editing:
            return
        year = int(0 if year == '' else year)
        try:
            self._datetime = self._datetime.replace(year=year)
            self.setDayValidator()
            self.calcInfo()
            win32api.SetSystemTime(*self.dt2t(self._datetime))
        except:
            pass

    def onMonthChanged(self, month):
        if not self.editing:
            return
        month = int(0 if month == '' else month)
        try:
            self._datetime = self._datetime.replace(month=month)
            self.setDayValidator()
            win32api.SetSystemTime(*self.dt2t(self._datetime))
        except:
            pass

    def onDayChanged(self, day):
        if not self.editing:
            return
        try:
            day = int(0 if day == '' else day)
            self._datetime = self._datetime.replace(day=day)
            win32api.SetSystemTime(*self.dt2t(self._datetime))
        except:
            pass

    def onHourChanged(self, hour):
        if not self.editing:
            return
        hour = int(0 if hour == '' else hour)
        try:
            self._datetime = self._datetime.replace(hour=hour)
            self.clock.hour = hour
            win32api.SetSystemTime(*self.dt2t(self._datetime))
        except:
            pass

    def onMinuteChanged(self, minute):
        if not self.editing:
            return
        minute = int(0 if minute == '' else minute)
        try:
            self._datetime = self._datetime.replace(minute=minute)
            self.clock.minute = minute
            win32api.SetSystemTime(*self.dt2t(self._datetime))
        except:
            pass

    def onSecondChanged(self, second):
        if not self.editing:
            return
        second = int(0 if second == '' else second)
        try:
            self._datetime = self._datetime.replace(second=second)
            self.clock.second = second
            win32api.SetSystemTime(*self.dt2t(self._datetime))
        except:
            pass

    def updateDatetime(self):
        self.ui.year_edit.setText(str(self._datetime.year))
        self.ui.month_edit.setText(str(self._datetime.month))
        self.ui.day_edit.setText(str(self._datetime.day))

        self.ui.hour_edit.setText(str(self._datetime.hour))
        self.ui.minute_edit.setText(str(self._datetime.minute))
        self.ui.second_edit.setText(str(self._datetime.second))

        self.clock.time = (self._datetime.hour, self._datetime.minute,
                           self._datetime.second)
        self.calcInfo()

    def timerEvent(self, event: QTimerEvent):
        if event.timerId() == self.timer_id and self.editing is False:
            self.time = datetime.now()