Option A
Option B
Error formatting HTML for problem:
{msg}').format(
- msg=str(error)
- )
-
- return HTML(
- "Could not format HTML for problem. Contact course staff in the discussion forum for assistance.
" - ) - - def submit_button_name(self): - """ - Determine the name for the "submit" button. - """ - # The logic flow is a little odd so that _('xxx') strings can be found for - # translation while also running _() just once for each string. - _ = self.runtime.service(self, "i18n").gettext - submit = _("Submit") - - return submit - - def submit_button_submitting_name(self): - """ - Return the "Submitting" text for the "submit" button. - - After the user presses the "submit" button, the button will briefly - display the value returned by this function until a response is - received by the server. - """ - _ = self.runtime.service(self, "i18n").gettext - return _("Submitting") - - def should_enable_submit_button(self): - """ - Return True/False to indicate whether to enable the "Submit" button. - """ - submitted_without_reset = self.is_submitted() and self.rerandomize == RANDOMIZATION.ALWAYS - - # If the problem is closed (past due / too many attempts) - # then we disable the "submit" button - # Also, disable the "submit" button if we're waiting - # for the user to reset a randomized problem - if self.closed() or submitted_without_reset: - return False - - return True - - def should_show_reset_button(self): - """ - Return True/False to indicate whether to show the "Reset" button. - """ - is_survey_question = self.max_attempts == 0 - - # If the problem is closed (and not a survey question with max_attempts==0), - # then do NOT show the reset button. - if self.closed() and not is_survey_question: - return False - - # Button only shows up for randomized problems if the question has been submitted - if self.rerandomize in [RANDOMIZATION.ALWAYS, RANDOMIZATION.ONRESET] and self.is_submitted(): - return True - - # Do NOT show the button if the problem is correct - if self.is_correct(): - return False - - return self.show_reset_button - - def should_show_save_button(self): - """ - Return True/False to indicate whether to show the "Save" button. - """ - - # If the user has forced the save button to display, - # then show it as long as the problem is not closed - # (past due / too many attempts) - if self.force_save_button: - return not self.closed() - - is_survey_question = self.max_attempts == 0 - needs_reset = self.is_submitted() and self.rerandomize == RANDOMIZATION.ALWAYS - - # If the student has unlimited attempts, and their answers - # are not randomized, then we do not need a save button - # because they can use the "Check" button without consequences. - # - # The consequences we want to avoid are: - # * Using up an attempt (if max_attempts is set) - # * Changing the current problem, and no longer being - # able to view it (if rerandomize is "always") - # - # In those cases. the if statement below is false, - # and the save button can still be displayed. - # - if self.max_attempts is None and self.rerandomize != RANDOMIZATION.ALWAYS: - return False - - # If the problem is closed (and not a survey question with max_attempts==0), - # then do NOT show the save button - # If we're waiting for the user to reset a randomized problem - # then do NOT show the save button - if (self.closed() and not is_survey_question) or needs_reset: - return False - - return True - - def handle_problem_html_error(self, err): - """ - Create a dummy problem to represent any errors. - - Change our problem to a dummy problem containing a warning message to - display to users. Returns the HTML to show to users - - `err` is the Exception encountered while rendering the problem HTML. - """ - problem_display_name = self.display_name_with_default - problem_location = str(self.location) - log.exception("ProblemGetHtmlError: %r, %r, %s", problem_display_name, problem_location, str(err)) - - if self.debug: - msg = HTML("[courseware.capa.capa_block] Failed to generate HTML for problem {url}").format( - url=str(self.location) - ) - msg += HTML("Error:
{msg}").format(msg=str(err))
- msg += HTML("{tb}").format(tb=traceback.format_exc())
- html = msg
-
- else:
- # We're in non-debug mode, and possibly even in production. We want
- # to avoid bricking of problem as much as possible
-
- # Presumably, student submission has corrupted LoncapaProblem HTML.
- # First, pull down all student answers
-
- student_answers = self.lcp.student_answers
- answer_ids = list(student_answers.keys())
-
- # Some inputtypes, such as dynamath, have additional "hidden" state that
- # is not exposed to the student. Keep those hidden
- # TODO: Use regex, e.g. 'dynamath' is suffix at end of answer_id
- hidden_state_keywords = ["dynamath"]
- for answer_id in answer_ids:
- for hidden_state_keyword in hidden_state_keywords:
- if answer_id.find(hidden_state_keyword) >= 0:
- student_answers.pop(answer_id)
-
- # Next, generate a fresh LoncapaProblem
- self.lcp = self.new_lcp(None)
- self.set_state_from_lcp()
- self.set_score(self.score_from_lcp(self.lcp))
- # Prepend a scary warning to the student
- _ = self.runtime.service(self, "i18n").gettext
- warning_msg = Text(_("Warning: The problem has been reset to its initial state!"))
- warning = HTML('{}
').format(warning_msg) - - # Translators: Following this message, there will be a bulleted list of items. - warning_msg = _("The problem's state was corrupted by an invalid submission. The submission consisted of:") - warning += HTML("{}- ").format(warning_msg)
-
- for student_answer in student_answers.values():
- if student_answer != "":
- warning += HTML("
- {} ").format(student_answer) - - warning_msg = _("If this error persists, please contact the course staff.") - warning += HTML("
- {hints}
- submit_notification (bool): True if the submit notification should be added
- """
- try:
- html = self.lcp.get_html()
-
- # If we cannot construct the problem HTML,
- # then generate an error message instead.
- except Exception as err: # pylint: disable=broad-exception-caught
- html = self.handle_problem_html_error(err)
-
- html = self.remove_tags_from_html(html)
- _ = self.runtime.service(self, "i18n").gettext
-
- # Enable/Disable Submit button if should_enable_submit_button returns True/False.
- submit_button = self.submit_button_name()
- submit_button_submitting = self.submit_button_submitting_name()
- should_enable_submit_button = self.should_enable_submit_button()
- submit_disabled_ctas = None
- if not should_enable_submit_button:
- cta_service = self.runtime.service(self, "call_to_action")
- if cta_service:
- submit_disabled_ctas = cta_service.get_ctas(self, "capa_submit_disabled")
-
- content = {
- "name": self.display_name_with_default,
- "html": smart_str(html),
- "weight": self.weight,
- }
-
- # If demand hints are available, emit hint button and div.
- demand_hints = self.lcp.tree.xpath("//problem/demandhint/hint")
- demand_hint_possible, should_enable_next_hint = self._should_enable_demand_hint(demand_hints=demand_hints)
-
- answer_notification_type, answer_notification_message = self._get_answer_notification(
- render_notifications=submit_notification
- )
-
- save_message = None
- if self.has_saved_answers:
- save_message = _("Your answers were previously saved. Click '{button_name}' to grade them.").format(
- button_name=self.submit_button_name()
- )
-
- context = {
- "problem": content,
- "id": str(self.location),
- "short_id": self.location.html_id(),
- "submit_button": submit_button,
- "submit_button_submitting": submit_button_submitting,
- "should_enable_submit_button": should_enable_submit_button,
- "reset_button": self.should_show_reset_button(),
- "save_button": self.should_show_save_button(),
- "answer_available": self.answer_available(),
- "grading_method": self.grading_method_display_name(),
- "attempts_used": self.attempts,
- "attempts_allowed": self.max_attempts,
- "demand_hint_possible": demand_hint_possible,
- "should_enable_next_hint": should_enable_next_hint,
- "answer_notification_type": answer_notification_type,
- "answer_notification_message": answer_notification_message,
- "has_saved_answers": self.has_saved_answers,
- "save_message": save_message,
- "submit_disabled_cta": submit_disabled_ctas[0] if submit_disabled_ctas else None,
- }
-
- html = render_to_string("problem.html", context)
-
- if encapsulate:
- html = HTML(' or which are not
- meant to be part of the client html. We strip them all and return the resulting html.
- """
- tags = [
- "demandhint",
- "choicehint",
- "optionhint",
- "stringhint",
- "numerichint",
- "optionhint",
- "correcthint",
- "regexphint",
- "additional_answer",
- "stringequalhint",
- "compoundhint",
- "stringequalhint",
- ]
- for tag in tags:
- html = re.sub(
- rf"<{tag}.*?>.*?", "", html, flags=re.DOTALL
- ) # xss-lint: disable=python-interpolate-html
- # Some of these tags span multiple lines
- # Note: could probably speed this up by calling sub() once with a big regex
- # vs. simply calling sub() many times as we have here.
- return html
-
- def hint_button(self, data):
- """
- Hint button handler, returns new html using hint_index from the client.
- """
- hint_index = int(data["hint_index"])
- return self.get_demand_hint(hint_index)
-
- def used_all_attempts(self):
- """All attempts have been used"""
- return self.max_attempts is not None and self.attempts >= self.max_attempts
-
- def is_past_due(self):
- """
- Is it now past this problem's due date, including grace period?
- """
- return self.close_date is not None and datetime.datetime.now(ZoneInfo("UTC")) > self.close_date
-
- def closed(self):
- """
- Is the student still allowed to submit answers?
- """
- if self.used_all_attempts():
- return True
- if self.is_past_due():
- return True
-
- return False
-
- def is_submitted(self):
- """
- Used to decide to show or hide RESET or CHECK buttons.
-
- Means that student submitted problem and nothing more.
- Problem can be completely wrong.
- Pressing RESET button makes this function to return False.
- """
- # used by conditional block
- return self.lcp.done
-
- def is_attempted(self):
- """
- Has the problem been attempted?
-
- used by conditional block
- """
- return self.attempts > 0
-
- def is_correct(self):
- """
- True iff full points
- """
- # self.score is initialized in self.lcp but in this method is accessed before self.lcp so just call it first.
- self.lcp # pylint: disable=pointless-statement # noqa: B018
- return self.score.raw_earned == self.score.raw_possible
-
- def answer_available(self): # pylint: disable=too-many-branches,too-many-return-statements
- """
- Is the user allowed to see an answer?
- """
- user_is_staff = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
- if not self.correctness_available():
- # If correctness is being withheld, then don't show answers either.
- return False
- if self.showanswer == "":
- return False
- if self.showanswer == SHOWANSWER.NEVER:
- return False
- if user_is_staff:
- # This is after the 'never' check because admins can see the answer
- # unless the problem explicitly prevents it
- return True
- if self.showanswer == SHOWANSWER.ATTEMPTED:
- return self.is_attempted() or self.is_past_due()
- if self.showanswer == SHOWANSWER.ANSWERED:
- # NOTE: this is slightly different from 'attempted' -- resetting the problems
- # makes lcp.done False, but leaves attempts unchanged.
- return self.is_correct()
- if self.showanswer == SHOWANSWER.CLOSED:
- return self.closed()
- if self.showanswer == SHOWANSWER.FINISHED:
- return self.closed() or self.is_correct()
-
- if self.showanswer == SHOWANSWER.CORRECT_OR_PAST_DUE:
- return self.is_correct() or self.is_past_due()
- if self.showanswer == SHOWANSWER.PAST_DUE:
- return self.is_past_due()
- if self.showanswer == SHOWANSWER.AFTER_SOME_NUMBER_OF_ATTEMPTS:
- required_attempts = self.attempts_before_showanswer_button
- if self.max_attempts and required_attempts >= self.max_attempts:
- required_attempts = self.max_attempts
- return self.attempts >= required_attempts
- if self.showanswer == SHOWANSWER.ALWAYS:
- return True
- if self.showanswer == SHOWANSWER.AFTER_ALL_ATTEMPTS:
- return self.used_all_attempts()
- if self.showanswer == SHOWANSWER.AFTER_ALL_ATTEMPTS_OR_CORRECT:
- return self.used_all_attempts() or self.is_correct()
- if self.showanswer == SHOWANSWER.ATTEMPTED_NO_PAST_DUE:
- return self.is_attempted()
- return False
-
- def correctness_available(self):
- """
- Is the user allowed to see whether she's answered correctly?
-
- Limits access to the correct/incorrect flags, messages, and problem score.
- """
- user_is_staff = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
- return ShowCorrectness.correctness_available(
- show_correctness=self.show_correctness,
- due_date=self.close_date,
- has_staff_access=user_is_staff,
- )
-
- def update_score(self, data):
- """
- Delivers grading response (e.g. from asynchronous code checking) to
- the capa problem, so its score can be updated
-
- 'data' must have a key 'response' which is a string that contains the
- grader's response
-
- No ajax return is needed. Return empty dict.
- """
- queuekey = data["queuekey"]
- score_msg = data["xqueue_body"]
- self.lcp.update_score(score_msg, queuekey)
- self.set_state_from_lcp()
- self.set_score(self.score_from_lcp(self.lcp))
- self.publish_grade(grader_response=True)
-
- return {} # No AJAX return is needed
-
- def handle_ungraded_response(self, data):
- """
- Delivers a response from the XQueue to the capa problem
-
- The score of the problem will not be updated
-
- Args:
- - data (dict) must contain keys:
- queuekey - a key specific to this response
- xqueue_body - the body of the response
- Returns:
- empty dictionary
-
- No ajax return is needed, so an empty dict is returned
- """
- queuekey = data["queuekey"]
- score_msg = data["xqueue_body"]
-
- # pass along the xqueue message to the problem
- self.lcp.ungraded_response(score_msg, queuekey)
- self.set_state_from_lcp()
- return {}
-
- def handle_input_ajax(self, data):
- """
- Handle ajax calls meant for a particular input in the problem
-
- Args:
- - data (dict) - data that should be passed to the input
- Returns:
- - dict containing the response from the input
- """
- response = self.lcp.handle_input_ajax(data)
-
- # save any state changes that may occur
- self.set_state_from_lcp()
- return response
-
- def get_answer(self, _data):
- """
- For the "show answer" button.
-
- Returns the answers and rendered "correct status span" HTML:
- {'answers' : answers, 'correct_status_html': correct_status_span_html}.
- The "correct status span" HTML is injected beside the correct answers
- for radio button and checkmark problems, so that there is a visual
- indication of the correct answers that is not solely based on color
- (and also screen reader text).
- """
- event_info = {}
- event_info["problem_id"] = str(self.location)
- self.publish_unmasked("showanswer", event_info)
- if not self.answer_available():
- raise NotFoundError("Answer is not available")
-
- answers = self.lcp.get_question_answers()
- self.set_state_from_lcp()
-
- # answers (eg ) may have embedded images
- # but be careful, some problems are using non-string answer dicts
- new_answers = {}
- for answer_id, answer_value in answers.items():
- try:
- answer_content = self.runtime.service(self, "replace_urls").replace_urls(answer_value)
- new_answer = {answer_id: answer_content}
- except TypeError:
- log.debug("Unable to perform URL substitution on answers[%s]: %s", answer_id, answer_value)
- new_answer = {answer_id: answer_value}
- new_answers.update(new_answer)
-
- return {
- "answers": new_answers,
- "correct_status_html": render_to_string(
- "status_span.html",
- {"status": Status("correct", self.runtime.service(self, "i18n").gettext)},
- ),
- }
-
- # Figure out if we should move these to capa_problem?
- def get_problem(self, _data):
- """
- Return results of get_problem_html, as a simple dict for json-ing.
- { 'html': }
-
- Used if we want to reconfirm we have the right thing e.g. after
- several AJAX calls.
- """
- return {"html": self.get_problem_html(encapsulate=False, submit_notification=True)}
-
- @staticmethod
- def make_dict_of_responses(data):
- """
- Make dictionary of student responses (aka "answers")
-
- `data` is POST dictionary (webob.multidict.MultiDict).
-
- The `data` dict has keys of the form 'x_y', which are mapped
- to key 'y' in the returned dict. For example,
- 'input_1_2_3' would be mapped to '1_2_3' in the returned dict.
-
- Some inputs always expect a list in the returned dict
- (e.g. checkbox inputs). The convention is that
- keys in the `data` dict that end with '[]' will always
- have list values in the returned dict.
- For example, if the `data` dict contains {'input_1[]': 'test' }
- then the output dict would contain {'1': ['test'] }
- (the value is a list).
-
- Some other inputs such as ChoiceTextInput expect a dict of values in the returned
- dict If the key ends with '{}' then we will assume that the value is a json
- encoded dict and deserialize it.
- For example, if the `data` dict contains {'input_1{}': '{"1_2_1": 1}'}
- then the output dict would contain {'1': {"1_2_1": 1} }
- (the value is a dictionary)
-
- Raises an exception if:
-
- -A key in the `data` dictionary does not contain at least one underscore
- (e.g. "input" is invalid, but "input_1" is valid)
-
- -Two keys end up with the same name in the returned dict.
- (e.g. 'input_1' and 'input_1[]', which both get mapped to 'input_1'
- in the returned dict)
- """
- answers = {}
-
- # webob.multidict.MultiDict is a view of a list of tuples,
- # so it will return a multi-value key once for each value.
- # We only want to consider each key a single time, so we use set(data.keys())
- for key in set(data.keys()):
- # e.g. input_resistor_1 ==> resistor_1
- _, _, name = key.partition("_")
-
- # If key has no underscores, then partition
- # will return (key, '', '')
- # We detect this and raise an error
- if not name:
- raise ValueError(f"{key} must contain at least one underscore")
-
- # This allows for answers which require more than one value for
- # the same form input (e.g. checkbox inputs). The convention is that
- # if the name ends with '[]' (which looks like an array), then the
- # answer will be an array.
- # if the name ends with '{}' (Which looks like a dict),
- # then the answer will be a dict
- is_list_key = name.endswith("[]")
- is_dict_key = name.endswith("{}")
- name = name[:-2] if is_list_key or is_dict_key else name
-
- if is_list_key:
- val = data.getall(key)
- elif is_dict_key:
- try:
- val = json.loads(data[key])
- # If the submission wasn't deserializable, raise an error.
- except (KeyError, ValueError) as exc:
- raise ValueError(f"Invalid submission: {data[key]} for {key}") from exc
- else:
- val = data[key]
-
- # If the name already exists, then we don't want
- # to override it. Raise an error instead
- if name in answers:
- raise ValueError(f"Key {name} already exists in answers dict")
-
- answers[name] = val
-
- return answers
-
- def publish_grade(self, score=None, only_if_higher=None, **kwargs):
- """
- Publishes the student's current grade to the system as an event
- """
- if not score:
- score = self.score
- event = {
- "value": score.raw_earned,
- "max_value": score.raw_possible,
- "only_if_higher": only_if_higher,
- }
- if kwargs.get("grader_response"):
- event["grader_response"] = kwargs["grader_response"]
-
- self.runtime.publish(self, "grade", event)
-
- return {"grade": self.score.raw_earned, "max_grade": self.score.raw_possible}
-
- def submit_problem( # pylint: disable=too-many-statements,too-many-branches,too-many-locals
- self, data, override_time=False
- ):
- """
- Checks whether answers to a problem are correct
-
- Returns a map of correct/incorrect answers:
- {'success' : 'correct' | 'incorrect' | AJAX alert msg string,
- 'contents' : html}
- """
- event_info = {}
- event_info["state"] = self.lcp.get_state()
- event_info["problem_id"] = str(self.location)
-
- self.lcp.has_saved_answers = False
- answers = self.make_dict_of_responses(data)
- answers_without_files = convert_files_to_filenames(answers)
- self.student_answers_history.append(answers_without_files)
- event_info["answers"] = answers_without_files
-
- # Can override current time
- current_time = datetime.datetime.now(ZoneInfo("UTC"))
- if override_time is not False:
- current_time = override_time
-
- _ = self.runtime.service(self, "i18n").gettext
-
- # Too late. Cannot submit
- if self.closed():
- log.error(
- "ProblemClosedError: Problem %s, close date: %s, due:%s, is_past_due: %s, attempts: %s/%s,",
- str(self.location),
- self.close_date,
- self.due,
- self.is_past_due(),
- self.attempts,
- self.max_attempts,
- )
- event_info["failure"] = "closed"
- self.publish_unmasked("problem_check_fail", event_info)
- raise NotFoundError(_("Problem is closed."))
-
- # Problem submitted. Student should reset before checking again
- if self.done and self.rerandomize == RANDOMIZATION.ALWAYS:
- event_info["failure"] = "unreset"
- self.publish_unmasked("problem_check_fail", event_info)
- raise NotFoundError(_("Problem must be reset before it can be submitted again."))
-
- # Problem queued. Students must wait a specified waittime before they are allowed to submit
- # IDEA: consider stealing code from below: pretty-print of seconds, cueing of time remaining
- if self.lcp.is_queued():
- prev_submit_time = self.lcp.get_recentmost_queuetime()
-
- xqueue_service = self.lcp.capa_system.xqueue
- waittime_between_requests = xqueue_service.waittime if xqueue_service else 0
- if (current_time - prev_submit_time).total_seconds() < waittime_between_requests:
- msg = _("You must wait at least {wait} seconds between submissions.").format(
- wait=waittime_between_requests
- )
- return {"success": msg, "html": ""}
-
- # Wait time between resets: check if is too soon for submission.
- if self.last_submission_time is not None and self.submission_wait_seconds not in [0, None]:
- seconds_since_submission = (current_time - self.last_submission_time).total_seconds()
- if seconds_since_submission < self.submission_wait_seconds:
- remaining_secs = int(self.submission_wait_seconds - seconds_since_submission)
- msg = _("You must wait at least {wait_secs} between submissions. {remaining_secs} remaining.").format(
- wait_secs=self.pretty_print_seconds(self.submission_wait_seconds),
- remaining_secs=self.pretty_print_seconds(remaining_secs),
- )
- return {"success": msg, "html": ""}
-
- try:
- # expose the attempt number to a potential python custom grader
- # self.lcp.context['attempt'] refers to the attempt number (1-based)
- self.lcp.context["attempt"] = self.attempts + 1
- correct_map = self.lcp.grade_answers(answers)
- # self.attempts refers to the number of attempts that did not
- # raise an error (0-based)
- self.attempts = self.attempts + 1
- self.lcp.done = True
- self.set_state_from_lcp()
-
- current_score = self.score_from_lcp(self.lcp)
- self.score_history.append(current_score)
- current_score = self.get_score_with_grading_method(current_score)
- self.set_score(current_score)
- self.set_last_submission_time()
-
- except (StudentInputError, ResponseError, LoncapaProblemError) as inst:
- if self.debug:
- log.warning("StudentInputError in capa_block:problem_check", exc_info=True)
-
- # Save the user's state before failing
- self.set_state_from_lcp()
- self.set_score(self.score_from_lcp(self.lcp))
-
- # If the user is a staff member, include
- # the full exception, including traceback,
- # in the response
- user_is_staff = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
- if user_is_staff:
- msg = f"Staff debug info: {traceback.format_exc()}"
-
- # Otherwise, display just an error message,
- # without a stack trace
- else:
- full_error = inst.args[0]
- try:
- # only return the error value of the exception
- msg = full_error.split("\\n")[-2].split(": ", 1)[1]
- except IndexError:
- msg = full_error
-
- return {"success": msg}
-
- except Exception as err:
- # Save the user's state before failing
- self.set_state_from_lcp()
- self.set_score(self.score_from_lcp(self.lcp))
-
- if self.debug:
- msg = f"Error checking problem: {str(err)}"
- msg += f"\nTraceback:\n{traceback.format_exc()}"
- return {"success": msg}
- raise
- published_grade = self.publish_grade()
-
- # success = correct if ALL questions in this problem are correct
- success = "correct"
- for answer_id in correct_map:
- if not correct_map.is_correct(answer_id):
- success = "incorrect"
-
- # NOTE: We are logging both full grading and queued-grading submissions. In the latter,
- # 'success' will always be incorrect
- event_info["grade"] = published_grade["grade"]
- event_info["max_grade"] = published_grade["max_grade"]
- event_info["correct_map"] = correct_map.get_dict()
- event_info["success"] = success
- event_info["attempts"] = self.attempts
- event_info["submission"] = self.get_submission_metadata_safe(answers_without_files, correct_map)
- self.publish_unmasked("problem_check", event_info)
-
- # render problem into HTML
- html = self.get_problem_html(encapsulate=False, submit_notification=True)
-
- # Withhold success indicator if hiding correctness
- if not self.correctness_available():
- success = "submitted"
-
- return {"success": success, "contents": html}
-
- def get_score_with_grading_method(self, current_score: Score) -> Score:
- """
- Calculate and return the current score based on the grading method.
-
- Args:
- current_score (Score): The current score of the LON-CAPA problem.
-
- In this method:
- - The current score is obtained from the LON-CAPA problem.
- - The score history is updated adding the current score.
-
- Returns:
- Score: The score based on the grading method.
- """
- grading_method_handler = GradingMethodHandler(
- current_score,
- self.grading_method,
- self.score_history,
- self.max_score(),
- )
- return grading_method_handler.get_score()
-
- def publish_unmasked(self, title, event_info):
- """
- All calls to runtime.publish route through here so that the
- choice names can be unmasked.
- """
- # Do the unmask translates on a copy of event_info,
- # avoiding problems where an event_info is unmasked twice.
- event_unmasked = copy.deepcopy(event_info)
- self.unmask_event(event_unmasked)
- self.runtime.publish(self, title, event_unmasked)
-
- def unmask_event(self, event_info):
- """
- Translates in-place the event_info to account for masking
- and adds information about permutation options in force.
- """
- # answers is like: {u'i4x-Stanford-CS99-problem-dada976e76f34c24bc8415039dee1300_2_1': u'mask_0'}
- # Each response values has an answer_id which matches the key in answers.
- for response in self.lcp.responders.values():
- # Un-mask choice names in event_info for masked responses.
- if response.has_mask():
- # We don't assume much about the structure of event_info,
- # but check for the existence of the things we need to un-mask.
-
- # Look for answers/id
- answer = event_info.get("answers", {}).get(response.answer_id)
- if answer is not None:
- event_info["answers"][response.answer_id] = response.unmask_name(answer)
-
- # Look for state/student_answers/id
- answer = event_info.get("state", {}).get("student_answers", {}).get(response.answer_id)
- if answer is not None:
- event_info["state"]["student_answers"][response.answer_id] = response.unmask_name(answer)
-
- # Look for old_state/student_answers/id -- parallel to the above case, happens on reset
- answer = event_info.get("old_state", {}).get("student_answers", {}).get(response.answer_id)
- if answer is not None:
- event_info["old_state"]["student_answers"][response.answer_id] = response.unmask_name(answer)
-
- # Add 'permutation' to event_info for permuted responses.
- permutation_option = None
- if response.has_shuffle():
- permutation_option = "shuffle"
- elif response.has_answerpool():
- permutation_option = "answerpool"
-
- if permutation_option is not None:
- # Add permutation record tuple: (one of:'shuffle'/'answerpool', [as-displayed list])
- if "permutation" not in event_info:
- event_info["permutation"] = {}
- event_info["permutation"][response.answer_id] = (permutation_option, response.unmask_order())
-
- def pretty_print_seconds(self, num_seconds):
- """
- Returns time duration nicely formated, e.g. "3 minutes 4 seconds"
- """
- # Here _ is the N variant ungettext that does pluralization with a 3-arg call
- ngettext = self.runtime.service(self, "i18n").ngettext
- hours = num_seconds // 3600
- sub_hour = num_seconds % 3600
- minutes = sub_hour // 60
- seconds = sub_hour % 60
- display = ""
- if hours > 0:
- display += ngettext("{num_hour} hour", "{num_hour} hours", hours).format(num_hour=hours)
- if minutes > 0:
- if display != "":
- display += " "
- # translators: "minute" refers to a minute of time
- display += ngettext("{num_minute} minute", "{num_minute} minutes", minutes).format(num_minute=minutes)
- # Taking care to make "0 seconds" instead of "" for 0 time
- if seconds > 0 or (hours == 0 and minutes == 0):
- if display != "":
- display += " "
- # translators: "second" refers to a second of time
- display += ngettext("{num_second} second", "{num_second} seconds", seconds).format(num_second=seconds)
- return display
-
- def get_submission_metadata_safe(self, answers, correct_map):
- """
- Ensures that no exceptions are thrown while generating input metadata summaries. Returns the
- summary if it is successfully created, otherwise an empty dictionary.
- """
- try:
- return self.get_submission_metadata(answers, correct_map)
- except Exception: # pylint: disable=broad-exception-caught
- # NOTE: The above process requires deep inspection of capa structures that may break for some
- # uncommon problem types. Ensure that it does not prevent answer submission in those
- # cases. Any occurrences of errors in this block should be investigated and resolved.
- log.exception("Unable to gather submission metadata, it will not be included in the event.")
-
- return {}
-
- def get_submission_metadata(self, answers, correct_map):
- """
- Return a map of inputs to their corresponding summarized metadata.
-
- Returns:
- A map whose keys are a unique identifier for the input (in this case a capa input_id) and
- whose values are:
-
- question (str): Is the prompt that was presented to the student. It corresponds to the
- label of the input.
- answer (mixed): Is the answer the student provided. This may be a rich structure,
- however it must be json serializable.
- response_type (str): The XML tag of the capa response type.
- input_type (str): The XML tag of the capa input type.
- correct (bool): Whether or not the provided answer is correct. Will be an empty
- string if correctness could not be determined.
- variant (str): In some cases the same question can have several different variants.
- This string should uniquely identify the variant of the question that was answered.
- In the capa context this corresponds to the `seed`.
-
- This function attempts to be very conservative and make very few assumptions about the structure
- of the problem. If problem related metadata cannot be located it should be replaced with empty
- strings ''.
- """
- input_metadata = {}
- for input_id, internal_answer in answers.items():
- answer_input = self.lcp.inputs.get(input_id)
-
- if answer_input is None:
- log.warning("Input id %s is not mapped to an input type.", input_id)
-
- answer_response = None
- for responder in self.lcp.responders.values():
- if input_id in responder.answer_ids:
- answer_response = responder
-
- if answer_response is None:
- log.warning("Answer responder could not be found for input_id %s.", input_id)
-
- user_visible_answer = internal_answer
- if hasattr(answer_input, "get_user_visible_answer"):
- user_visible_answer = answer_input.get_user_visible_answer(internal_answer)
-
- # If this problem has rerandomize enabled, then it will generate N variants of the
- # question, one per unique seed value. In this case we would like to know which
- # variant was selected. Ideally it would be nice to have the exact question that
- # was presented to the user, with values interpolated etc, but that can be done
- # later if necessary.
- variant = ""
- if self.rerandomize != RANDOMIZATION.NEVER:
- variant = self.get_seed()
-
- is_correct = correct_map.is_correct(input_id)
- if is_correct is None:
- is_correct = ""
-
- response_data = getattr(answer_input, "response_data", {})
- input_metadata[input_id] = {
- "question": response_data.get("label", ""),
- "answer": user_visible_answer,
- "response_type": getattr(getattr(answer_response, "xml", None), "tag", ""),
- "input_type": getattr(answer_input, "tag", ""),
- "correct": is_correct,
- "variant": variant,
- "group_label": response_data.get("group_label", ""),
- }
-
- return input_metadata
-
- def save_problem(self, data):
- """
- Save the passed in answers.
- Returns a dict { 'success' : bool, 'msg' : message }
- The message is informative on success, and an error message on failure.
- """
- event_info = {}
- event_info["state"] = self.lcp.get_state()
- event_info["problem_id"] = str(self.location)
-
- answers = self.make_dict_of_responses(data)
- event_info["answers"] = answers
- _ = self.runtime.service(self, "i18n").gettext
-
- # Too late. Cannot submit
- if self.closed() and not self.max_attempts == 0:
- event_info["failure"] = "closed"
- self.publish_unmasked("save_problem_fail", event_info)
- return {
- "success": False,
- # Translators: 'closed' means the problem's due date has passed.
- # You may no longer attempt to solve the problem.
- "msg": _("Problem is closed."),
- }
-
- # Problem submitted. Student should reset before saving
- # again.
- if self.done and self.rerandomize == RANDOMIZATION.ALWAYS:
- event_info["failure"] = "done"
- self.publish_unmasked("save_problem_fail", event_info)
- return {"success": False, "msg": _("Problem needs to be reset prior to save.")}
-
- self.lcp.student_answers = answers
- self.lcp.has_saved_answers = True
-
- self.set_state_from_lcp()
- self.set_score(self.score_from_lcp(self.lcp))
-
- self.publish_unmasked("save_problem_success", event_info)
- msg = _("Your answers have been saved.")
- if not self.max_attempts == 0:
- msg = _("Your answers have been saved but not graded. Click '{button_name}' to grade them.").format(
- button_name=self.submit_button_name()
- )
- return {"success": True, "msg": msg, "html": self.get_problem_html(encapsulate=False)}
-
- def reset_problem(self, _data):
- """
- Changes problem state to unfinished -- removes student answers,
- Causes problem to rerender itself if randomization is enabled.
-
- Returns a dictionary of the form:
- {'success': True/False,
- 'html': Problem HTML string }
-
- If an error occurs, the dictionary will also have an
- `error` key containing an error message.
- """
- event_info = {}
- event_info["old_state"] = self.lcp.get_state()
- event_info["problem_id"] = str(self.location)
- _ = self.runtime.service(self, "i18n").gettext
-
- if self.closed():
- event_info["failure"] = "closed"
- self.publish_unmasked("reset_problem_fail", event_info)
- return {
- "success": False,
- # Translators: 'closed' means the problem's due date has passed.
- # You may no longer attempt to solve the problem.
- "msg": _("You cannot select Reset for a problem that is closed."),
- }
-
- if not self.is_submitted():
- event_info["failure"] = "not_done"
- self.publish_unmasked("reset_problem_fail", event_info)
- return {
- "success": False,
- "msg": _("You must submit an answer before you can select Reset."),
- }
-
- if self.is_submitted() and self.rerandomize in [RANDOMIZATION.ALWAYS, RANDOMIZATION.ONRESET]:
- # Reset random number generator seed.
- self.choose_new_seed()
-
- # Generate a new problem with either the previous seed or a new seed
- self.lcp = self.new_lcp(None)
-
- # Pull in the new problem seed
- self.set_state_from_lcp()
- self.set_score(self.score_from_lcp(self.lcp))
-
- # Grade may have changed, so publish new value
- self.publish_grade()
-
- event_info["new_state"] = self.lcp.get_state()
- self.publish_unmasked("reset_problem", event_info)
-
- return {
- "success": True,
- "html": self.get_problem_html(encapsulate=False),
- }
-
- # ScorableXBlockMixin methods
-
- def rescore(self, only_if_higher=False):
- """
- Checks whether the existing answers to a problem are correct.
-
- This is called when the correct answer to a problem has been changed,
- and the grade should be re-evaluated.
-
- If only_if_higher is True, the answer and grade are updated
- only if the resulting score is higher than before.
-
- Returns a dict with one key:
- {'success' : 'correct' | 'incorrect' | AJAX alert msg string }
-
- Raises NotFoundError if called on a problem that has not yet been
- answered, or NotImplementedError if it's a problem that cannot be rescored.
-
- Returns the error messages for exceptions occurring while performing
- the rescoring, rather than throwing them.
- """
- event_info = {"state": self.lcp.get_state(), "problem_id": str(self.location)}
-
- _ = self.runtime.service(self, "i18n").gettext
-
- if not self.lcp.supports_rescoring():
- event_info["failure"] = "unsupported"
- self.publish_unmasked("problem_rescore_fail", event_info)
-
- # Translators: 'rescoring' refers to the act of re-submitting a student's
- # solution so it can get a new score.
- raise NotImplementedError(_("Problem's definition does not support rescoring."))
-
- if not self.done:
- event_info["failure"] = "unanswered"
- self.publish_unmasked("problem_rescore_fail", event_info)
- raise NotFoundError(_("Problem must be answered before it can be graded again."))
-
- # get old score, for comparison:
- orig_score = self.get_score()
- event_info["orig_score"] = orig_score.raw_earned
- event_info["orig_total"] = orig_score.raw_possible
- try:
- calculated_score = self.calculate_score()
- except (
- StudentInputError,
- ResponseError,
- LoncapaProblemError,
- ):
- log.warning("Input error in capa_block:problem_rescore", exc_info=True)
- event_info["failure"] = "input_error"
- self.publish_unmasked("problem_rescore_fail", event_info)
- raise
-
- except Exception:
- event_info["failure"] = "unexpected"
- self.publish_unmasked("problem_rescore_fail", event_info)
- raise
-
- # rescoring should have no effect on attempts, so don't
- # need to increment here, or mark done. Just save.
- self.set_state_from_lcp()
- self.publish_grade(score=calculated_score, only_if_higher=only_if_higher)
-
- event_info["new_score"] = calculated_score.raw_earned
- event_info["new_total"] = calculated_score.raw_possible
-
- # success = correct if ALL questions in this problem are correct
- success = "correct"
- for answer_id in self.lcp.correct_map:
- if not self.lcp.correct_map.is_correct(answer_id):
- success = "incorrect"
-
- # NOTE: We are logging both full grading and queued-grading submissions. In the latter,
- # 'success' will always be incorrect
- event_info["correct_map"] = self.lcp.correct_map.get_dict()
- event_info["success"] = success
- event_info["attempts"] = self.attempts
- self.publish_unmasked("problem_rescore", event_info)
-
- def get_rescore_with_grading_method(self) -> Score:
- """
- Calculate and return the rescored score based on the grading method.
-
- In this method:
- - The list with the correctness maps is updated.
- - The list with the score history is updated based on the correctness maps.
- - The final score is calculated based on the grading method.
-
- Returns:
- Score: The score calculated based on the grading method.
- """
- self.update_correctness_list()
- self.score_history = self.calculate_score_list()
- grading_method_handler = GradingMethodHandler(
- self.score,
- self.grading_method,
- self.score_history,
- self.max_score(),
- )
- return grading_method_handler.get_score()
-
- def has_submitted_answer(self):
- """Return True if the learner has already submitted an answer."""
- return self.done
-
- def set_score(self, score):
- """
- Sets the internal score for the problem. This is not derived directly
- from the internal LCP in keeping with the ScorableXBlock spec.
- """
- self.score = score
-
- def get_score(self):
- """
- Returns the score currently set on the block.
- """
- return self.score
-
- def update_correctness_list(self):
- """
- Updates the `correct_map_history` and the `correct_map` of the LCP.
-
- Operates by creating a new correctness map based on the current
- state of the LCP, and updating the old correctness map of the LCP.
- """
- # Make sure that the attempt number is always at least 1 for grading purposes,
- # even if the number of attempts have been reset and this problem is regraded.
- self.lcp.context["attempt"] = max(self.attempts, 1)
- new_correct_map_list = []
- for student_answers, correct_map in zip(self.student_answers_history, self.correct_map_history): # noqa: B905
- new_correct_map = self.lcp.get_grade_from_current_answers(student_answers, correct_map)
- new_correct_map_list.append(new_correct_map)
- self.lcp.correct_map_history = new_correct_map_list
- if new_correct_map_list:
- self.lcp.correct_map.update(new_correct_map_list[-1])
-
- def calculate_score(self):
- """
- Returns the score calculated from the current problem state.
-
- The score is calculated based on the grading method.
- """
- return self.get_rescore_with_grading_method()
-
- def calculate_score_list(self):
- """
- Returns the score calculated from the current problem state.
- """
- new_score_list = []
-
- for correct_map in self.lcp.correct_map_history:
- new_score = self.lcp.calculate_score(correct_map)
- new_score_list.append(Score(raw_earned=new_score["score"], raw_possible=new_score["total"]))
- return new_score_list
-
- def score_from_lcp(self, lcp):
- """
- Returns the score associated with the correctness map
- currently stored by the LCP.
- """
- lcp_score = lcp.calculate_score()
- return Score(raw_earned=lcp_score["score"], raw_possible=lcp_score["total"])
-
-
-class GradingMethodHandler:
- """
- A class for handling grading method and calculating scores.
-
- This class allows for flexible handling of grading methods, including options
- such as considering the last score, the first score, the highest score,
- or the average score.
-
- Attributes:
- - score (Score): The current score.
- - grading_method (str): The chosen grading method.
- - score_history (list[Score]): A list to store the history of scores.
- - max_score (int): The maximum possible score.
- - mapping_method (dict): A dictionary mapping the grading
- method to the corresponding handler.
-
- Methods:
- - get_score(): Retrieves the updated score based on the grading method.
- - handle_last_score(): Handles the last score method.
- - handle_first_score(): Handles the first score method.
- - handle_highest_score(): Handles the highest score method.
- - handle_average_score(): Handles the average score method.
- """
-
- def __init__(
- self,
- score: Score,
- grading_method: str,
- score_history: list[Score],
- max_score: int,
- ):
- self.score = score
- self.grading_method = grading_method
- self.score_history = score_history
- if not self.score_history:
- self.score_history.append(score)
- self.max_score = max_score
- self.mapping_method = {
- GRADING_METHOD.LAST_SCORE: self.handle_last_score,
- GRADING_METHOD.FIRST_SCORE: self.handle_first_score,
- GRADING_METHOD.HIGHEST_SCORE: self.handle_highest_score,
- GRADING_METHOD.AVERAGE_SCORE: self.handle_average_score,
- }
-
- def get_score(self) -> Score:
- """
- Retrieves the updated score based on the grading method.
-
- Returns:
- - Score: The updated score based on the chosen grading method.
- """
- return self.mapping_method[self.grading_method]()
-
- def handle_last_score(self) -> Score:
- """
- Retrieves the score based on the last score.
- It is the last score in the score history.
-
- Returns:
- - Score: The score based on the last score.
- """
- return self.score_history[-1]
-
- def handle_first_score(self) -> Score:
- """
- Retrieves the score based on the first score.
- It is the first score in the score history.
-
- Returns:
- - Score: The score based on the first score.
- """
- return self.score_history[0]
-
- def handle_highest_score(self) -> Score:
- """
- Retrieves the score based on the highest score.
- It is the highest score in the score history.
-
- Returns:
- - Score: The score based on the highest score.
- """
- return max(self.score_history)
-
- def handle_average_score(self) -> Score:
- """
- Calculates the average score based on all attempts. The average score is
- the sum of all scores divided by the number of scores.
-
- Returns:
- - Score: The average score based on all attempts.
- """
- total = sum(score.raw_earned for score in self.score_history)
- average_score = round(total / len(self.score_history), 2)
- return Score(raw_earned=average_score, raw_possible=self.max_score)
-
-
-class ComplexEncoder(json.JSONEncoder):
- """
- Extend the JSON encoder to correctly handle complex numbers
- """
-
- def default(self, o):
- """
- Print a nicely formatted complex number, or default to the JSON encoder
- """
- if isinstance(o, complex):
- return f"{o.real:.7g}{o.imag:+.7g}*j"
- return json.JSONEncoder.default(self, o)
-
-
-def randomization_bin(seed, problem_id):
- """
- Pick a randomization bin for the problem given the user's seed and a problem id.
-
- We do this because we only want e.g. 20 randomizations of a problem to make analytics
- interesting. To avoid having sets of students that always get the same problems,
- we'll combine the system's per-student seed with the problem id in picking the bin.
- """
- r_hash = hashlib.sha256()
- r_hash.update(str(seed).encode())
- r_hash.update(str(problem_id).encode())
- # get the first few digits of the hash, convert to an int, then mod.
- return int(r_hash.hexdigest()[:7], 16) % NUM_RANDOMIZATION_BINS
-
-
-ProblemBlock = None
-
-
-def reset_class():
- """Reset class as per django settings flag"""
- global ProblemBlock
- ProblemBlock = (
- _ExtractedProblemBlock if settings.USE_EXTRACTED_PROBLEM_BLOCK else _BuiltInProblemBlock
- )
- return ProblemBlock
-
-
-reset_class()
-ProblemBlock.__name__ = "ProblemBlock"
diff --git a/xmodule/js/fixtures/problem.html b/xmodule/js/fixtures/problem.html
deleted file mode 100644
index 841b8dc144c8..000000000000
--- a/xmodule/js/fixtures/problem.html
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-
-
diff --git a/xmodule/js/fixtures/problem_content.html b/xmodule/js/fixtures/problem_content.html
deleted file mode 100644
index 9f252b6fb0a6..000000000000
--- a/xmodule/js/fixtures/problem_content.html
+++ /dev/null
@@ -1,44 +0,0 @@
- \
- \
- \
- \
-`);
- expect(this.problem999.element_id).toBe("problem_999");
- });
-
- it("set the element from loadFixtures", function () {
- this.problem1 = new Problem($(".xblock-student_view"));
- expect(this.problem1.element_id).toBe("problem_1");
- });
- });
-
- describe("bind", function () {
- beforeEach(function () {
- spyOn(window, "update_schematics");
- MathJax.Hub.getAllJax.and.returnValue([this.stubbedJax]);
- this.problem = new Problem($(".xblock-student_view"));
- });
-
- it("set mathjax typeset", () => expect(MathJax.Hub.Queue).toHaveBeenCalled());
-
- it("update schematics", () => expect(window.update_schematics).toHaveBeenCalled());
-
- it("bind answer refresh on button click", function () {
- expect($("div.action button")).toHandleWith("click", this.problem.refreshAnswers);
- });
-
- it("bind the submit button", function () {
- expect($(".action .submit")).toHandleWith("click", this.problem.submit_fd);
- });
-
- it("bind the reset button", function () {
- expect($("div.action button.reset")).toHandleWith("click", this.problem.reset);
- });
-
- it("bind the show button", function () {
- expect($(".action .show")).toHandleWith("click", this.problem.show);
- });
-
- it("bind the save button", function () {
- expect($("div.action button.save")).toHandleWith("click", this.problem.save);
- });
-
- it("bind the math input", function () {
- expect($("input.math")).toHandleWith("keyup", this.problem.refreshMath);
- });
- });
-
- describe("bind_with_custom_input_id", function () {
- beforeEach(function () {
- spyOn(window, "update_schematics");
- MathJax.Hub.getAllJax.and.returnValue([this.stubbedJax]);
- this.problem = new Problem($(".xblock-student_view"));
- return $(this).html(readFixtures("problem_content_1240.html"));
- });
-
- it("bind the submit button", function () {
- expect($(".action .submit")).toHandleWith("click", this.problem.submit_fd);
- });
-
- it("bind the show button", function () {
- expect($("div.action button.show")).toHandleWith("click", this.problem.show);
- });
- });
-
- describe("renderProgressState", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- });
-
- const testProgessData = function (
- problem,
- score,
- total_possible,
- attempts,
- graded,
- expected_progress_after_render,
- ) {
- problem.el.data("problem-score", score);
- problem.el.data("problem-total-possible", total_possible);
- problem.el.data("attempts-used", attempts);
- problem.el.data("graded", graded);
- expect(problem.$(".problem-progress").html()).toEqual("");
- problem.renderProgressState();
- expect(problem.$(".problem-progress").html()).toEqual(expected_progress_after_render);
- };
-
- describe('with a status of "none"', function () {
- it("reports the number of points possible and graded", function () {
- testProgessData(this.problem, 0, 1, 0, "True", "1 point possible (graded)");
- });
-
- it("displays the number of points possible when rendering happens with the content", function () {
- testProgessData(this.problem, 0, 2, 0, "True", "2 points possible (graded)");
- });
-
- it("reports the number of points possible and ungraded", function () {
- testProgessData(this.problem, 0, 1, 0, "False", "1 point possible (ungraded)");
- });
-
- it("displays ungraded if number of points possible is 0", function () {
- testProgessData(this.problem, 0, 0, 0, "False", "0 points possible (ungraded)");
- });
-
- it("displays ungraded if number of points possible is 0, even if graded value is True", function () {
- testProgessData(this.problem, 0, 0, 0, "True", "0 points possible (ungraded)");
- });
-
- it("reports the correct score with status none and >0 attempts", function () {
- testProgessData(this.problem, 0, 1, 1, "True", "0/1 point (graded)");
- });
-
- it("reports the correct score with >1 weight, status none, and >0 attempts", function () {
- testProgessData(this.problem, 0, 2, 2, "True", "0/2 points (graded)");
- });
- });
-
- describe("with any other valid status", function () {
- it("reports the current score", function () {
- testProgessData(this.problem, 1, 1, 1, "True", "1/1 point (graded)");
- });
-
- it("shows current score when rendering happens with the content", function () {
- testProgessData(this.problem, 2, 2, 1, "True", "2/2 points (graded)");
- });
-
- it("reports the current score even if problem is ungraded", function () {
- testProgessData(this.problem, 1, 1, 1, "False", "1/1 point (ungraded)");
- });
- });
-
- describe('with valid status and string containing an integer like "0" for detail', () =>
- // These tests are to address a failure specific to Chrome 51 and 52 +
- it("shows 0 points possible for the detail", function () {
- testProgessData(this.problem, 0, 0, 1, "False", "0 points possible (ungraded)");
- }));
-
- describe("with a score of null (show_correctness == false)", function () {
- it("reports the number of points possible and graded, results hidden", function () {
- testProgessData(this.problem, null, 1, 0, "True", "1 point possible (graded, results hidden)");
- });
-
- it("reports the number of points possible (plural) and graded, results hidden", function () {
- testProgessData(this.problem, null, 2, 0, "True", "2 points possible (graded, results hidden)");
- });
-
- it("reports the number of points possible and ungraded, results hidden", function () {
- testProgessData(this.problem, null, 1, 0, "False", "1 point possible (ungraded, results hidden)");
- });
-
- it("displays ungraded if number of points possible is 0, results hidden", function () {
- testProgessData(this.problem, null, 0, 0, "False", "0 points possible (ungraded, results hidden)");
- });
-
- it("displays ungraded if number of points possible is 0, even if graded value is True, results hidden", function () {
- testProgessData(this.problem, null, 0, 0, "True", "0 points possible (ungraded, results hidden)");
- });
-
- it("reports the correct score with status none and >0 attempts, results hidden", function () {
- testProgessData(this.problem, null, 1, 1, "True", "1 point possible (graded, results hidden)");
- });
-
- it("reports the correct score with >1 weight, status none, and >0 attempts, results hidden", function () {
- testProgessData(this.problem, null, 2, 2, "True", "2 points possible (graded, results hidden)");
- });
- });
- });
-
- describe("render", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.bind = this.problem.bind;
- spyOn(this.problem, "bind");
- });
-
- describe("with content given", function () {
- beforeEach(function () {
- this.problem.render("Hello World");
- });
-
- it("render the content", function () {
- expect(this.problem.el.html()).toEqual("Hello World");
- });
-
- it("re-bind the content", function () {
- expect(this.problem.bind).toHaveBeenCalled();
- });
- });
-
- describe("with no content given", function () {
- beforeEach(function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) => callback({ html: "Hello World" }));
- this.problem.render();
- });
-
- it("load the content via ajax", function () {
- expect(this.problem.el.html()).toEqual("Hello World");
- });
-
- it("re-bind the content", function () {
- expect(this.problem.bind).toHaveBeenCalled();
- });
- });
- });
-
- describe("submit_fd", function () {
- beforeEach(function () {
- // Insert an input of type file outside of the problem.
- $(".xblock-student_view").after('');
- this.problem = new Problem($(".xblock-student_view"));
- spyOn(this.problem, "submit");
- });
-
- it("submit method is called if input of type file is not in problem", function () {
- this.problem.submit_fd();
- expect(this.problem.submit).toHaveBeenCalled();
- });
- });
-
- describe("submit", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.answers = "foo=1&bar=2";
- });
-
- it("log the problem_check event", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- promise = {
- always(callable) {
- return callable();
- },
- done(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.submit();
- expect(Logger.log).toHaveBeenCalledWith("problem_check", "foo=1&bar=2");
- });
-
- it("log the problem_graded event, after the problem is done grading.", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- const response = {
- success: "correct",
- contents: "mock grader response",
- };
- callback(response);
- promise = {
- always(callable) {
- return callable();
- },
- done(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.submit();
- expect(Logger.log).toHaveBeenCalledWith(
- "problem_graded",
- ["foo=1&bar=2", "mock grader response"],
- this.problem.id,
- );
- });
-
- it("submit the answer for submit", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- promise = {
- always(callable) {
- return callable();
- },
- done(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.submit();
- expect($.postWithPrefix).toHaveBeenCalledWith(
- "/problem/Problem1/problem_check",
- "foo=1&bar=2",
- jasmine.any(Function),
- );
- });
-
- describe("when the response is correct", () =>
- it("call render with returned content", function () {
- const contents =
- '' +
- '';
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- callback({ success: "correct", contents });
- promise = {
- always(callable) {
- return callable();
- },
- done(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.submit();
- expect(this.problem.el).toHaveHtml(contents);
- expect(window.SR.readTexts).toHaveBeenCalledWith(["Question 1: excellent", "Question 2: correct"]);
- }));
-
- describe("when the response is incorrect", () =>
- it("call render with returned content", function () {
- const contents = '
-
-
-
-
- \
-`;
- beforeEach(function () {
- // Append a radiotextresponse problem to the problem, so we can check it's javascript functionality
- this.problem.el.prepend(radio_text_xml);
- });
-
- it("sets the correct class on the section for the correct choice", function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) =>
- callback({ answers: { "1_2_1": ["1_2_1_choiceinput_0bc"], "1_2_1_choiceinput_0bc": "3" } }),
- );
- this.problem.show();
-
- expect($("#forinput1_2_1_choiceinput_0bc").attr("class")).toEqual("choicetextgroup_show_correct");
- expect($("#answer_1_2_1_choiceinput_0bc").text()).toEqual("3");
- expect($("#answer_1_2_1_choiceinput_1bc").text()).toEqual("");
- expect($("#answer_1_2_1_choiceinput_2bc").text()).toEqual("");
- });
-
- it("Should not disable input fields", function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) =>
- callback({ answers: { "1_2_1": ["1_2_1_choiceinput_0bc"], "1_2_1_choiceinput_0bc": "3" } }),
- );
- this.problem.show();
- expect($("input#1_2_1_choiceinput_0bc").attr("disabled")).not.toEqual("disabled");
- expect($("input#1_2_1_choiceinput_1bc").attr("disabled")).not.toEqual("disabled");
- expect($("input#1_2_1_choiceinput_2bc").attr("disabled")).not.toEqual("disabled");
- expect($("input#1_2_1").attr("disabled")).not.toEqual("disabled");
- });
- });
-
- describe("imageinput", function () {
- let el, height, width;
- const imageinput_html = readFixtures("imageinput.underscore");
-
- const DEFAULTS = {
- id: "12345",
- width: "300",
- height: "400",
- };
-
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.el.prepend(_.template(imageinput_html)(DEFAULTS));
- });
-
- const assertAnswer = (problem, data) => {
- stubRequest(data);
- problem.show();
-
- $.each(data["answers"], (id, answer) => {
- const img = getImage(answer);
- el = $(`#inputtype_${id}`);
- expect(img).toImageDiffEqual(el.find("canvas")[0]);
- });
- };
-
- var stubRequest = (data) => {
- spyOn($, "postWithPrefix").and.callFake((url, callback) => callback(data));
- };
-
- var getImage = (coords, c_width, c_height) => {
- let ctx, reg;
- const types = {
- rectangle: (coords) => {
- reg = /^\(([0-9]+),([0-9]+)\)-\(([0-9]+),([0-9]+)\)$/;
- const rects = coords.replace(/\s*/g, "").split(/;/);
-
- $.each(rects, (index, rect) => {
- const { abs } = Math;
- const points = reg.exec(rect);
- if (points) {
- width = abs(points[3] - points[1]);
- height = abs(points[4] - points[2]);
-
- return ctx.rect(points[1], points[2], width, height);
- }
- });
-
- ctx.stroke();
- ctx.fill();
- },
-
- regions: (coords) => {
- const parseCoords = (coords) => {
- reg = JSON.parse(coords);
-
- if (typeof reg[0][0][0] === "undefined") {
- reg = [reg];
- }
-
- return reg;
- };
-
- return $.each(parseCoords(coords), (index, region) => {
- ctx.beginPath();
- $.each(region, (index, point) => {
- if (index === 0) {
- return ctx.moveTo(point[0], point[1]);
- } else {
- return ctx.lineTo(point[0], point[1]);
- }
- });
-
- ctx.closePath();
- ctx.stroke();
- ctx.fill();
- });
- },
- };
-
- const canvas = document.createElement("canvas");
- canvas.width = c_width || 100;
- canvas.height = c_height || 100;
-
- if (canvas.getContext) {
- ctx = canvas.getContext("2d");
- } else {
- console.log("Canvas is not supported.");
- }
-
- ctx.fillStyle = "rgba(255,255,255,.3)";
- ctx.strokeStyle = "#FF0000";
- ctx.lineWidth = "2";
-
- $.each(coords, (key, value) => {
- if (types[key] != null && value) {
- return types[key](value);
- }
- });
-
- return canvas;
- };
-
- it("rectangle is drawn correctly", function () {
- assertAnswer(this.problem, {
- answers: {
- 12345: {
- rectangle: "(10,10)-(30,30)",
- regions: null,
- },
- },
- });
- });
-
- it("region is drawn correctly", function () {
- assertAnswer(this.problem, {
- answers: {
- 12345: {
- rectangle: null,
- regions: "[[10,10],[30,30],[70,30],[20,30]]",
- },
- },
- });
- });
-
- it("mixed shapes are drawn correctly", function () {
- assertAnswer(this.problem, {
- answers: {
- 12345: {
- rectangle: "(10,10)-(30,30);(5,5)-(20,20)",
- regions: `[
- [[50,50],[40,40],[70,30],[50,70]],
- [[90,95],[95,95],[90,70],[70,70]]
-]`,
- },
- },
- });
- });
-
- it("multiple image inputs draw answers on separate canvases", function () {
- const data = {
- id: "67890",
- width: "400",
- height: "300",
- };
-
- this.problem.el.prepend(_.template(imageinput_html)(data));
- assertAnswer(this.problem, {
- answers: {
- 12345: {
- rectangle: null,
- regions: "[[10,10],[30,30],[70,30],[20,30]]",
- },
- 67890: {
- rectangle: "(10,10)-(30,30)",
- regions: null,
- },
- },
- });
- });
-
- it("dictionary with answers doesn't contain answer for current id", function () {
- spyOn(console, "log");
- stubRequest({ answers: {} });
- this.problem.show();
- el = $("#inputtype_12345");
- expect(el.find("canvas")).not.toExist();
- expect(console.log).toHaveBeenCalledWith("Answer is absent for image input with id=12345");
- });
- });
- });
- });
-
- describe("save", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.answers = "foo=1&bar=2";
- });
-
- it("log the problem_save event", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.save();
- expect(Logger.log).toHaveBeenCalledWith("problem_save", "foo=1&bar=2");
- });
-
- it("POST to save problem", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.save();
- expect($.postWithPrefix).toHaveBeenCalledWith(
- "/problem/Problem1/problem_save",
- "foo=1&bar=2",
- jasmine.any(Function),
- );
- });
-
- it("tests that save does not enable the submit button or change the text when submit is originally disabled", function () {
- const self = this;
- const curr_html = this.problem.el.html();
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- // enableButtons should have been called at this point and the submit button should be unaffected
- let promise;
- expect(self.problem.submitButton).toHaveAttr("disabled");
- expect(self.problem.submitButtonLabel.text()).toBe("Submit");
- callback({ success: "correct", html: curr_html });
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- // Expect submit to be disabled and labeled properly at the start
- expect(this.problem.submitButton).toHaveAttr("disabled");
- expect(this.problem.submitButtonLabel.text()).toBe("Submit");
- this.problem.save();
- // Submit button should have the same state after save has completed
- expect(this.problem.submitButton).toHaveAttr("disabled");
- expect(this.problem.submitButtonLabel.text()).toBe("Submit");
- });
-
- it("tests that save does not disable the submit button or change the text when submit is originally enabled", function () {
- const self = this;
- const curr_html = this.problem.el.html();
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- // enableButtons should have been called at this point, and the submit button should be disabled while submitting
- let promise;
- expect(self.problem.submitButton).toHaveAttr("disabled");
- expect(self.problem.submitButtonLabel.text()).toBe("Submit");
- callback({ success: "correct", html: curr_html });
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- // Expect submit to be enabled and labeled properly at the start after adding an input
- $("#input_example_1").val("test").trigger("input");
- expect(this.problem.submitButton).not.toHaveAttr("disabled");
- expect(this.problem.submitButtonLabel.text()).toBe("Submit");
- this.problem.save();
- // Submit button should have the same state after save has completed
- expect(this.problem.submitButton).not.toHaveAttr("disabled");
- expect(this.problem.submitButtonLabel.text()).toBe("Submit");
- });
- });
-
- describe("refreshMath", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- // Reset Queue spy so that bind()'s Queue call ([fn, null, domEl]) is not
- // included when toHaveBeenCalledWith scans recorded calls. In Jasmine 2.99,
- // toHaveBeenCalledWith iterates ALL recorded calls' args element-by-element
- // (even mismatched ones, for diff output). jasmine-jquery's custom equality
- // tester calls $(domEl).is(anyString) when comparing a DOM node against a
- // string — which throws a Sizzle syntax error if the string isn't a valid
- // CSS selector (e.g. "E=mc^2"). Resetting here isolates this describe to
- // testing only what refreshMath itself queues.
- MathJax.Hub.Queue.calls.reset();
- $("#input_example_1").val("E=mc^2");
- this.problem.refreshMath({ target: $("#input_example_1").get(0) });
- });
-
- it("should queue the conversion and MathML element update", function () {
- expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
- ["Text", this.stubbedJax, "E=mc^2"],
- [this.problem.updateMathML, this.stubbedJax, $("#input_example_1").get(0)],
- );
- });
- });
-
- describe("updateMathML", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.stubbedJax.root.toMathML.and.returnValue("");
- });
-
- describe("when there is no exception", function () {
- beforeEach(function () {
- this.problem.updateMathML(this.stubbedJax, $("#input_example_1").get(0));
- });
-
- it("convert jax to MathML", () => expect($("#input_example_1_dynamath")).toHaveValue(""));
- });
-
- describe("when there is an exception", function () {
- beforeEach(function () {
- const error = new Error();
- error.restart = true;
- this.stubbedJax.root.toMathML.and.throwError(error);
- this.problem.updateMathML(this.stubbedJax, $("#input_example_1").get(0));
- });
-
- it("should queue up the exception", function () {
- expect(MathJax.Callback.After).toHaveBeenCalledWith([this.problem.refreshMath, this.stubbedJax], true);
- });
- });
- });
-
- describe("refreshAnswers", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.el.html(`\
-
-
-
-\
-`);
- this.stubSchematic = { update_value: jasmine.createSpy("schematic") };
- this.stubCodeMirror = { save: jasmine.createSpy("CodeMirror") };
- $("input.schematic").get(0).schematic = this.stubSchematic;
- $("textarea.CodeMirror").get(0).CodeMirror = this.stubCodeMirror;
- });
-
- it("update each schematic", function () {
- this.problem.refreshAnswers();
- expect(this.stubSchematic.update_value).toHaveBeenCalled();
- });
-
- it("update each code block", function () {
- this.problem.refreshAnswers();
- expect(this.stubCodeMirror.save).toHaveBeenCalled();
- });
- });
-
- describe("multiple JsInput in single problem", function () {
- const jsinput_html = readFixtures("jsinput_problem.html");
-
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.render(jsinput_html);
- });
-
- it("submit_save_waitfor should return false", function () {
- $(this.problem.inputs[0]).data("waitfor", function () {});
- expect(this.problem.submit_save_waitfor()).toEqual(false);
- });
- });
-
- describe("Submitting an xqueue-graded problem", function () {
- const matlabinput_html = readFixtures("matlabinput_problem.html");
-
- beforeEach(function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) => callback({ html: matlabinput_html }));
- jasmine.clock().install();
- this.problem = new Problem($(".xblock-student_view"));
- spyOn(this.problem, "poll").and.callThrough();
- this.problem.render(matlabinput_html);
- });
-
- afterEach(() => jasmine.clock().uninstall());
-
- it("check that we stop polling after a fixed amount of time", function () {
- expect(this.problem.poll).not.toHaveBeenCalled();
- jasmine.clock().tick(1);
- const time_steps = [1000, 2000, 4000, 8000, 16000, 32000];
- let num_calls = 1;
- for (let time_step of Array.from(time_steps)) {
- ((time_step) => {
- jasmine.clock().tick(time_step);
- expect(this.problem.poll.calls.count()).toEqual(num_calls);
- num_calls += 1;
- })(time_step);
- }
-
- // jump the next step and verify that we are not still continuing to poll
- jasmine.clock().tick(64000);
- expect(this.problem.poll.calls.count()).toEqual(6);
-
- expect($(".notification-gentle-alert .notification-message").text()).toEqual(
- "The grading process is still running. Refresh the page to see updates.",
- );
- });
- });
-
- describe("codeinput problem", function () {
- const codeinputProblemHtml = readFixtures("codeinput_problem.html");
-
- beforeEach(function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) => callback({ html: codeinputProblemHtml }));
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.render(codeinputProblemHtml);
- });
-
- it("has rendered with correct a11y info", function () {
- const CodeMirrorTextArea = $("textarea")[1];
- const CodeMirrorTextAreaId = "cm-textarea-101";
-
- // verify that question label has correct `for` attribute value
- expect($(".problem-group-label").attr("for")).toEqual(CodeMirrorTextAreaId);
-
- // verify that codemirror textarea has correct `id` attribute value
- expect($(CodeMirrorTextArea).attr("id")).toEqual(CodeMirrorTextAreaId);
-
- // verify that codemirror textarea has correct `aria-describedby` attribute value
- expect($(CodeMirrorTextArea).attr("aria-describedby")).toEqual("cm-editor-exit-message-101 status_101");
- });
- });
-
- describe("show answer button", function () {
- const radioButtonProblemHtml = readFixtures("radiobutton_problem.html");
- const checkboxProblemHtml = readFixtures("checkbox_problem.html");
-
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
-
- this.checkAssertionsAfterClickingAnotherOption = () => {
- // verify that 'show answer button is no longer disabled'
- expect(this.problem.el.find(".show").attr("disabled")).not.toEqual("disabled");
-
- // verify that displayed answer disappears
- expect(this.problem.el.find("div.choicegroup")).not.toHaveClass("choicegroup_correct");
-
- // verify that radio/checkbox label has no span having class '.status.correct'
- expect(this.problem.el.find("div.choicegroup")).not.toHaveAttr("span.status.correct");
- };
- });
-
- it("should become enabled after a radiobutton is selected", function () {
- $("#input_example_1").replaceWith(radioButtonProblemHtml);
- // assume that 'ShowAnswer' button is clicked,
- // clicking make it disabled.
- this.problem.el.find(".show").attr("disabled", "disabled");
- // bind click event to input fields
- this.problem.submitAnswersAndSubmitButton(true);
- // selects option 2
- $("#input_1_1_2").attr("checked", true).trigger("click");
- this.checkAssertionsAfterClickingAnotherOption();
- });
-
- it("should become enabled after a checkbox is selected", function () {
- $("#input_example_1").replaceWith(checkboxProblemHtml);
- this.problem.el.find(".show").attr("disabled", "disabled");
- this.problem.submitAnswersAndSubmitButton(true);
- $("#input_1_1_2").click();
- this.checkAssertionsAfterClickingAnotherOption();
- });
- });
-});
diff --git a/xmodule/js/spec/capa/imageinput_spec.js b/xmodule/js/spec/capa/imageinput_spec.js
deleted file mode 100644
index f6c2f9f95376..000000000000
--- a/xmodule/js/spec/capa/imageinput_spec.js
+++ /dev/null
@@ -1,132 +0,0 @@
-/**
- * "Beware of bugs in the above code; I have only proved it correct, not tried
- * it."
- *
- * ~ Donald Knuth
- */
-
-// eslint-disable-next-line no-shadow-restricted-names
-(function ($, ImageInput, undefined) {
- describe("ImageInput", function () {
- var state;
-
- beforeEach(function () {
- var $el;
-
- loadFixtures("imageinput.html");
- $el = $("#imageinput_12345");
-
- $el.append(createTestImage("cross_12345", 300, 400, "red"));
-
- state = new ImageInput("12345");
- });
-
- it("initialization", function () {
- // Check that object's properties are present, and that the DOM
- // elements they reference exist.
- expect(state.el).toBeDefined();
- expect(state.el).toExist();
-
- expect(state.crossEl).toBeDefined();
- expect(state.crossEl).toExist();
-
- expect(state.inputEl).toBeDefined();
- expect(state.inputEl).toExist();
-
- expect(state.el).toHandle("click");
- });
-
- it("cross becomes visible after first click", function () {
- expect(state.crossEl.css("visibility")).toBe("hidden");
-
- state.el.click();
-
- expect(state.crossEl.css("visibility")).toBe("visible");
- });
-
- it("coordinates are updated [offsetX is set]", function () {
- var event, posX, posY, cssLeft, cssTop;
-
- // Set up of 'click' event.
- event = jQuery.Event("click", { offsetX: 35.3, offsetY: 42.7 });
-
- // Calculating the expected coordinates.
- posX = event.offsetX;
- posY = event.offsetY;
-
- // Triggering 'click' event.
- jQuery(state.el).trigger(event);
-
- // Getting actual (new) coordinates, and testing them against the
- // expected.
- cssLeft = stripPx(state.crossEl.css("left"));
- cssTop = stripPx(state.crossEl.css("top"));
-
- expect(cssLeft).toBeCloseTo(posX - 15, 1);
- expect(cssTop).toBeCloseTo(posY - 15, 1);
- expect(state.inputEl.val()).toBe("[" + Math.round(posX) + "," + Math.round(posY) + "]");
- });
-
- it("coordinates are updated [offsetX is NOT set]", function () {
- var offset = state.el.offset(),
- event,
- posX,
- posY,
- cssLeft,
- cssTop;
-
- // Set up of 'click' event.
- event = jQuery.Event("click", {
- offsetX: undefined,
- offsetY: undefined,
- pageX: 35.3,
- pageY: 42.7,
- });
-
- // Calculating the expected coordinates.
- posX = event.pageX - offset.left;
- posY = event.pageY - offset.top;
-
- // Triggering 'click' event.
- jQuery(state.el).trigger(event);
-
- // Getting actual (new) coordinates, and testing them against the
- // expected.
- cssLeft = stripPx(state.crossEl.css("left"));
- cssTop = stripPx(state.crossEl.css("top"));
-
- expect(cssLeft).toBeCloseTo(posX - 15, 1);
- expect(cssTop).toBeCloseTo(posY - 15, 1);
- expect(state.inputEl.val()).toBe("[" + Math.round(posX) + "," + Math.round(posY) + "]");
- });
- });
-
- // Instead of storing an image, and then including it in the template via
- // the ![]()
tag, we will generate one on the fly.
- //
- // Create a simple image from a canvas. The canvas is filled by a colored
- // rectangle.
- function createTestImage(id, width, height, fillStyle) {
- var canvas, ctx, img;
-
- canvas = document.createElement("canvas");
- canvas.width = width;
- canvas.height = height;
-
- ctx = canvas.getContext("2d");
- ctx.fillStyle = fillStyle;
- ctx.fillRect(0, 0, width, height);
-
- img = document.createElement("img");
- img.src = canvas.toDataURL("image/png");
- img.id = id;
-
- return img;
- }
-
- // Strip the trailing 'px' substring from a CSS string containing the
- // `left` and `top` properties of an element's style.
- function stripPx(str) {
- return str.substring(0, str.length - 2);
- }
-}).call(this, window.jQuery, window.ImageInput);
diff --git a/xmodule/js/src/capa/display.js b/xmodule/js/src/capa/display.js
deleted file mode 100644
index fea25a654049..000000000000
--- a/xmodule/js/src/capa/display.js
+++ /dev/null
@@ -1,1411 +0,0 @@
-/* global MathJax, Collapsible, interpolate, JavascriptLoader, Logger, CodeMirror */
-// Note: this code was originally converted from CoffeeScript, and thus follows some
-// coding conventions that are discouraged by eslint. Some warnings have been suppressed
-// to avoid substantial rewriting of the code. Allow the eslint suppressions to exceed
-// the max line length of 120.
-/* eslint max-len: ["error", 120, { "ignoreComments": true }] */
-
-(function () {
- "use strict";
-
- var indexOfHelper =
- [].indexOf ||
- function (item) {
- var i, len;
- for (i = 0, len = this.length; i < len; i++) {
- if (i in this && this[i] === item) {
- return i;
- }
- }
- return -1;
- };
-
- this.Problem = function () {
- function Problem(element) {
- var that = this;
- this.hint_button = function () {
- return Problem.prototype.hint_button.apply(that, arguments);
- };
- this.enableSubmitButtonAfterTimeout = function () {
- return Problem.prototype.enableSubmitButtonAfterTimeout.apply(that, arguments);
- };
- this.enableSubmitButtonAfterResponse = function () {
- return Problem.prototype.enableSubmitButtonAfterResponse.apply(that, arguments);
- };
- this.enableSubmitButton = function (enable, changeText) {
- if (changeText === null || changeText === undefined) {
- changeText = true; // eslint-disable-line no-param-reassign
- }
- return Problem.prototype.enableSubmitButton.apply(that, arguments);
- };
- this.disableAllButtonsWhileRunning = function (
- operationCallback,
- isFromCheckOperation, // eslint-disable-line no-unused-vars
- ) {
- return Problem.prototype.disableAllButtonsWhileRunning.apply(that, arguments);
- };
- this.submitAnswersAndSubmitButton = function (bind) {
- if (bind === null || bind === undefined) {
- bind = false; // eslint-disable-line no-param-reassign
- }
- return Problem.prototype.submitAnswersAndSubmitButton.apply(that, arguments);
- };
- this.refreshAnswers = function () {
- return Problem.prototype.refreshAnswers.apply(that, arguments);
- };
- this.updateMathML = function (jax, el) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.updateMathML.apply(that, arguments);
- };
- this.refreshMath = function (event, el) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.refreshMath.apply(that, arguments);
- };
- this.save_internal = function () {
- return Problem.prototype.save_internal.apply(that, arguments);
- };
- this.save = function () {
- return Problem.prototype.save.apply(that, arguments);
- };
- this.gentle_alert = function (msg) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.gentle_alert.apply(that, arguments);
- };
- this.clear_all_notifications = function () {
- return Problem.prototype.clear_all_notifications.apply(that, arguments);
- };
- this.show = function () {
- return Problem.prototype.show.apply(that, arguments);
- };
- this.reset_internal = function () {
- return Problem.prototype.reset_internal.apply(that, arguments);
- };
- this.reset = function () {
- return Problem.prototype.reset.apply(that, arguments);
- };
- this.get_sr_status = function (contents) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.get_sr_status.apply(that, arguments);
- };
- this.submit_internal = function () {
- return Problem.prototype.submit_internal.apply(that, arguments);
- };
- this.submit = function () {
- return Problem.prototype.submit.apply(that, arguments);
- };
- this.submit_fd = function () {
- return Problem.prototype.submit_fd.apply(that, arguments);
- };
- this.focus_on_save_notification = function () {
- return Problem.prototype.focus_on_save_notification.apply(that, arguments);
- };
- this.focus_on_hint_notification = function () {
- return Problem.prototype.focus_on_hint_notification.apply(that, arguments);
- };
- this.focus_on_submit_notification = function () {
- return Problem.prototype.focus_on_submit_notification.apply(that, arguments);
- };
- this.focus_on_notification = function (type) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.focus_on_notification.apply(that, arguments);
- };
- this.scroll_to_problem_meta = function () {
- return Problem.prototype.scroll_to_problem_meta.apply(that, arguments);
- };
- this.submit_save_waitfor = function (callback) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.submit_save_waitfor.apply(that, arguments);
- };
- this.setupInputTypes = function () {
- return Problem.prototype.setupInputTypes.apply(that, arguments);
- };
- this.poll = function (
- prevTimeout,
- focusCallback, // eslint-disable-line no-unused-vars
- ) {
- return Problem.prototype.poll.apply(that, arguments);
- };
- this.queueing = function (focusCallback) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.queueing.apply(that, arguments);
- };
- this.forceUpdate = function (response) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.forceUpdate.apply(that, arguments);
- };
- this.updateProgress = function (response) {
- // eslint-disable-line no-unused-vars
- return Problem.prototype.updateProgress.apply(that, arguments);
- };
- this.renderProgressState = function () {
- return Problem.prototype.renderProgressState.apply(that, arguments);
- };
- this.bind = function () {
- return Problem.prototype.bind.apply(that, arguments);
- };
- this.el = $(element).find(".problems-wrapper");
- this.id = this.el.data("problem-id");
- this.element_id = this.el.attr("id");
- this.url = this.el.data("url");
- this.content = this.el.data("content");
-
- // has_timed_out and has_response are used to ensure that
- // we wait a minimum of ~ 1s before transitioning the submit
- // button from disabled to enabled
- this.has_timed_out = false;
- this.has_response = false;
- this.render(this.content);
- }
-
- Problem.prototype.$ = function (selector) {
- return $(selector, this.el);
- };
-
- Problem.prototype.bind = function () {
- var problemPrefix,
- that = this;
- if (typeof MathJax !== "undefined" && MathJax !== null) {
- this.el.find(".problem > div").each(function (index, element) {
- return MathJax.Hub.Queue(["Typeset", MathJax.Hub, element]);
- });
- }
- if (window.hasOwnProperty("update_schematics")) {
- window.update_schematics();
- }
- problemPrefix = this.element_id.replace(/problem_/, "");
- this.inputs = this.$('[id^="input_' + problemPrefix + '_"]');
- this.$("div.action button").click(this.refreshAnswers);
- this.reviewButton = this.$(".notification-btn.review-btn");
- this.reviewButton.click(this.scroll_to_problem_meta);
- this.submitButton = this.$(".action .submit");
- this.submitButtonLabel = this.$(".action .submit .submit-label");
- this.submitButtonSubmitText = this.submitButtonLabel.text();
- this.submitButtonSubmittingText = this.submitButton.data("submitting");
- this.submitButton.click(this.submit_fd);
- this.hintButton = this.$(".action .hint-button");
- this.hintButton.click(this.hint_button);
- this.resetButton = this.$(".action .reset");
- this.resetButton.click(this.reset);
- this.showButton = this.$(".action .show");
- this.showButton.click(this.show);
- this.saveButton = this.$(".action .save");
- this.saveNotification = this.$(".notification-save");
- this.showAnswerNotification = this.$(".notification-show-answer");
- this.saveButton.click(this.save);
- this.gentleAlertNotification = this.$(".notification-gentle-alert");
- this.submitNotification = this.$(".notification-submit");
-
- // Accessibility helper for sighted keyboard users to show tooltips on focus:
- this.$(".clarification").focus(function (ev) {
- var icon;
- icon = $(ev.target).children("i");
- return window.globalTooltipManager.openTooltip(icon);
- });
- this.$(".clarification").blur(function () {
- return window.globalTooltipManager.hide();
- });
- this.$(".review-btn").focus(function (ev) {
- return $(ev.target).removeClass("sr");
- });
- this.$(".review-btn").blur(function (ev) {
- return $(ev.target).addClass("sr");
- });
- this.bindResetCorrectness();
- if (this.submitButton.length) {
- this.submitAnswersAndSubmitButton(true);
- }
- Collapsible.setCollapsibles(this.el);
- this.$("input.math").keyup(this.refreshMath);
- if (typeof MathJax !== "undefined" && MathJax !== null) {
- this.$("input.math").each(function (index, element) {
- return MathJax.Hub.Queue([that.refreshMath, null, element]);
- });
- }
- };
-
- Problem.prototype.renderProgressState = function () {
- var graded, progress, progressTemplate, curScore, totalScore, attemptsUsed;
- curScore = this.el.data("problem-score");
- totalScore = this.el.data("problem-total-possible");
- attemptsUsed = this.el.data("attempts-used");
- graded = this.el.data("graded");
-
- // The problem is ungraded if it's explicitly marked as such, or if the total possible score is 0
- if (graded === "True" && totalScore !== 0) {
- graded = true;
- } else {
- graded = false;
- }
-
- if (curScore === undefined || totalScore === undefined) {
- // Render an empty string.
- progressTemplate = "";
- } else if (curScore === null || curScore === "None") {
- // Render 'x point(s) possible (un/graded, results hidden)' if no current score provided.
- if (graded) {
- progressTemplate = ngettext(
- // Translators: {num_points} is the number of points possible (examples: 1, 3, 10).;
- "{num_points} point possible (graded, results hidden)",
- "{num_points} points possible (graded, results hidden)",
- totalScore,
- );
- } else {
- progressTemplate = ngettext(
- // Translators: {num_points} is the number of points possible (examples: 1, 3, 10).;
- "{num_points} point possible (ungraded, results hidden)",
- "{num_points} points possible (ungraded, results hidden)",
- totalScore,
- );
- }
- } else if ((attemptsUsed === 0 || totalScore === 0) && curScore === 0) {
- // Render 'x point(s) possible' if student has not yet attempted question
- // But if staff has overridden score to a non-zero number, show it
- if (graded) {
- progressTemplate = ngettext(
- // Translators: {num_points} is the number of points possible (examples: 1, 3, 10).;
- "{num_points} point possible (graded)",
- "{num_points} points possible (graded)",
- totalScore,
- );
- } else {
- progressTemplate = ngettext(
- // Translators: {num_points} is the number of points possible (examples: 1, 3, 10).;
- "{num_points} point possible (ungraded)",
- "{num_points} points possible (ungraded)",
- totalScore,
- );
- }
- } else {
- // Render 'x/y point(s)' if student has attempted question
- if (graded) {
- progressTemplate = ngettext(
- // This comment needs to be on one line to be properly scraped for the translators.
- // Translators: {earned} is the number of points earned. {possible} is the total number of points (examples: 0/1, 1/1, 2/3, 5/10). The total number of points will always be at least 1. We pluralize based on the total number of points (example: 0/1 point; 1/2 points);
- "{earned}/{possible} point (graded)",
- "{earned}/{possible} points (graded)",
- totalScore,
- );
- } else {
- progressTemplate = ngettext(
- // This comment needs to be on one line to be properly scraped for the translators.
- // Translators: {earned} is the number of points earned. {possible} is the total number of points (examples: 0/1, 1/1, 2/3, 5/10). The total number of points will always be at least 1. We pluralize based on the total number of points (example: 0/1 point; 1/2 points);
- "{earned}/{possible} point (ungraded)",
- "{earned}/{possible} points (ungraded)",
- totalScore,
- );
- }
- }
- progress = edx.StringUtils.interpolate(progressTemplate, {
- earned: curScore,
- num_points: totalScore,
- possible: totalScore,
- });
- return this.$(".problem-progress").text(progress);
- };
-
- Problem.prototype.updateProgress = function (response) {
- if (response.progress_changed) {
- this.el.data("problem-score", this.convertToFloat(response.current_score));
- this.el.data("problem-total-possible", this.convertToFloat(response.total_possible));
- this.el.data("attempts-used", response.attempts_used);
- this.el.trigger("progressChanged");
- }
- return this.renderProgressState();
- };
-
- Problem.prototype.convertToFloat = function (num) {
- if (typeof num !== "number" || !Number.isInteger(num)) {
- return num;
- }
- return num.toFixed(1);
- };
-
- Problem.prototype.forceUpdate = function (response) {
- this.el.data("problem-score", response.current_score);
- this.el.data("problem-total-possible", response.total_possible);
- this.el.data("attempts-used", response.attempts_used);
- this.el.trigger("progressChanged");
- return this.renderProgressState();
- };
-
- Problem.prototype.queueing = function (focusCallback) {
- var that = this;
- this.queued_items = this.$(".xqueue");
- this.num_queued_items = this.queued_items.length;
- if (this.num_queued_items > 0) {
- if (window.queuePollerID) {
- // Only one poller 'thread' per Problem
- window.clearTimeout(window.queuePollerID);
- }
- window.queuePollerID = window.setTimeout(function () {
- return that.poll(1000, focusCallback);
- }, 1000);
- }
- };
-
- Problem.prototype.poll = function (previousTimeout, focusCallback) {
- var that = this;
- return $.postWithPrefix("" + this.url + "/problem_get", function (response) {
- var newTimeout;
- // If queueing status changed, then render
- that.new_queued_items = $(response.html).find(".xqueue");
- if (that.new_queued_items.length !== that.num_queued_items) {
- edx.HtmlUtils.setHtml(that.el, edx.HtmlUtils.HTML(response.html))
- .promise()
- .done(function () {
- // eslint-disable-next-line no-void
- return typeof focusCallback === "function" ? focusCallback() : void 0;
- });
- JavascriptLoader.executeModuleScripts(that.el, function () {
- that.setupInputTypes();
- that.bind();
- });
- }
- that.num_queued_items = that.new_queued_items.length;
- if (that.num_queued_items === 0) {
- that.forceUpdate(response);
- delete window.queuePollerID;
- } else {
- newTimeout = previousTimeout * 2;
- // if the timeout is greather than 1 minute
- if (newTimeout >= 60000) {
- delete window.queuePollerID;
- that.gentle_alert(gettext("The grading process is still running. Refresh the page to see updates."));
- } else {
- window.queuePollerID = window.setTimeout(function () {
- return that.poll(newTimeout, focusCallback);
- }, newTimeout);
- }
- }
- });
- };
-
- /**
- * Use this if you want to make an ajax call on the input type object
- * static method so you don't have to instantiate a Problem in order to use it
- *
- * Input:
- * url: the AJAX url of the problem
- * inputId: the inputId of the input you would like to make the call on
- * NOTE: the id is the ${id} part of "input_${id}" during rendering
- * If this function is passed the entire prefixed id, the backend may have trouble
- * finding the correct input
- * dispatch: string that indicates how this data should be handled by the inputtype
- * data: dictionary of data to send to the server
- * callback: the function that will be called once the AJAX call has been completed.
- * It will be passed a response object
- */
- Problem.inputAjax = function (url, inputId, dispatch, data, callback) {
- data.dispatch = dispatch; // eslint-disable-line no-param-reassign
- data.input_id = inputId; // eslint-disable-line no-param-reassign
- return $.postWithPrefix("" + url + "/input_ajax", data, callback);
- };
-
- Problem.prototype.render = function (content, focusCallback) {
- var that = this;
- if (content) {
- edx.HtmlUtils.setHtml(this.el, edx.HtmlUtils.HTML(content));
- return JavascriptLoader.executeModuleScripts(this.el, function () {
- that.setupInputTypes();
- that.bind();
- that.queueing(focusCallback);
- that.renderProgressState();
- // eslint-disable-next-line no-void
- return typeof focusCallback === "function" ? focusCallback() : void 0;
- });
- } else {
- return $.postWithPrefix("" + this.url + "/problem_get", function (response) {
- edx.HtmlUtils.setHtml(that.el, edx.HtmlUtils.HTML(response.html));
- return JavascriptLoader.executeModuleScripts(that.el, function () {
- that.setupInputTypes();
- that.bind();
- that.queueing();
- return that.forceUpdate(response);
- });
- });
- }
- };
-
- Problem.prototype.setupInputTypes = function () {
- var that = this;
- this.inputtypeDisplays = {};
- return this.el.find(".capa_inputtype").each(function (index, inputtype) {
- var classes, cls, id, setupMethod, i, len, results;
- classes = $(inputtype).attr("class").split(" ");
- id = $(inputtype).attr("id");
- results = [];
- for (i = 0, len = classes.length; i < len; i++) {
- cls = classes[i];
- setupMethod = that.inputtypeSetupMethods[cls];
- if (setupMethod != null) {
- results.push((that.inputtypeDisplays[id] = setupMethod(inputtype)));
- } else {
- // eslint-disable-next-line no-void
- results.push(void 0);
- }
- }
- return results;
- });
- };
-
- /**
- * If some function wants to be called before sending the answer to the
- * server, give it a chance to do so.
- *
- * submit_save_waitfor allows the callee to send alerts if the user's input is
- * invalid. To do so, the callee must throw an exception named "WaitforException".
- * This and any other errors or exceptions that arise from the callee are rethrown
- * and abort the submission.
- *
- * In order to use this feature, add a 'data-waitfor' attribute to the input,
- * and specify the function to be called by the submit button before sending off @answers
- */
- Problem.prototype.submit_save_waitfor = function (callback) {
- var flag,
- inp,
- i,
- len,
- ref,
- that = this;
- flag = false;
- ref = this.inputs;
- for (i = 0, len = ref.length; i < len; i++) {
- inp = ref[i];
- if ($(inp).is("input[waitfor]")) {
- try {
- $(inp).data("waitfor")(function () {
- that.refreshAnswers();
- return callback();
- });
- } catch (e) {
- if (e.name === "Waitfor Exception") {
- alert(e.message); // eslint-disable-line no-alert
- } else {
- alert(
- // eslint-disable-line no-alert
- gettext("Could not grade your answer. The submission was aborted."),
- );
- }
- throw e;
- }
- flag = true;
- } else {
- flag = false;
- }
- }
- return flag;
- };
-
- // Scroll to problem metadata and next focus is problem input
- Problem.prototype.scroll_to_problem_meta = function () {
- var questionTitle;
- questionTitle = this.$(".problem-header");
- if (questionTitle.length > 0) {
- $("html, body").animate(
- {
- scrollTop: questionTitle.offset().top,
- },
- 500,
- );
- questionTitle.focus();
- }
- };
-
- Problem.prototype.focus_on_notification = function (type) {
- var notification;
- notification = this.$(".notification-" + type);
- if (notification.length > 0) {
- notification.focus();
- }
- };
-
- Problem.prototype.focus_on_submit_notification = function () {
- this.focus_on_notification("submit");
- };
-
- Problem.prototype.focus_on_hint_notification = function (hintIndex) {
- this.$(".notification-hint .notification-message > ol > li.hint-index-" + hintIndex).focus();
- };
-
- Problem.prototype.focus_on_save_notification = function () {
- this.focus_on_notification("save");
- };
-
- /**
- * 'submit_fd' uses FormData to allow file submissions in the 'problem_check' dispatch,
- * in addition to simple querystring-based answers
- *
- * NOTE: The dispatch 'problem_check' is being singled out for the use of FormData;
- * maybe preferable to consolidate all dispatches to use FormData
- */
- Problem.prototype.submit_fd = function () {
- var abortSubmission,
- error,
- errorHtml,
- errors,
- fd,
- fileNotSelected,
- fileTooLarge,
- maxFileSize,
- requiredFilesNotSubmitted,
- settings,
- timeoutId,
- unallowedFileSubmitted,
- i,
- len,
- that = this;
-
- // If there are no file inputs in the problem, we can fall back on submit.
- if (this.el.find("input:file").length === 0) {
- this.submit();
- return;
- }
- this.enableSubmitButton(false);
- if (!window.FormData) {
- alert(
- gettext(
- "Submission aborted! Sorry, your browser does not support file uploads. If you can, please use Chrome or Safari which have been verified to support file uploads.",
- ),
- ); // eslint-disable-line max-len, no-alert
- this.enableSubmitButton(true);
- return;
- }
- timeoutId = this.enableSubmitButtonAfterTimeout();
- fd = new FormData();
-
- // Sanity checks on submission
- maxFileSize = 4 * 1000 * 1000;
- fileTooLarge = false;
- fileNotSelected = false;
- requiredFilesNotSubmitted = false;
- unallowedFileSubmitted = false;
-
- errors = [];
- this.inputs.each(function (index, element) {
- var allowedFiles, file, maxSize, requiredFiles, loopI, loopLen, ref;
- if (element.type === "file") {
- requiredFiles = $(element).data("required_files");
- allowedFiles = $(element).data("allowed_files");
- ref = element.files;
- for (loopI = 0, loopLen = ref.length; loopI < loopLen; loopI++) {
- file = ref[loopI];
- if (allowedFiles.length !== 0 && indexOfHelper.call(allowedFiles, file.name) < 0) {
- unallowedFileSubmitted = true;
- errors.push(
- edx.StringUtils.interpolate(gettext("You submitted {filename}; only {allowedFiles} are allowed."), {
- filename: file.name,
- allowedFiles: allowedFiles,
- }),
- );
- }
- if (indexOfHelper.call(requiredFiles, file.name) >= 0) {
- requiredFiles.splice(requiredFiles.indexOf(file.name), 1);
- }
- if (file.size > maxFileSize) {
- fileTooLarge = true;
- maxSize = maxFileSize / (1000 * 1000);
- errors.push(
- edx.StringUtils.interpolate(gettext("Your file {filename} is too large (max size: {maxSize}MB)."), {
- filename: file.name,
- maxSize: maxSize,
- }),
- );
- }
- fd.append(element.id, file); // xss-lint: disable=javascript-jquery-append
- }
- if (element.files.length === 0) {
- fileNotSelected = true;
- // In case we want to allow submissions with no file
- fd.append(element.id, ""); // xss-lint: disable=javascript-jquery-append
- }
- if (requiredFiles.length !== 0) {
- requiredFilesNotSubmitted = true;
- errors.push(
- edx.StringUtils.interpolate(gettext("You did not submit the required files: {requiredFiles}."), {
- requiredFiles: requiredFiles,
- }),
- );
- }
- } else {
- fd.append(element.id, element.value); // xss-lint: disable=javascript-jquery-append
- }
- });
- if (fileNotSelected) {
- errors.push(gettext("You did not select any files to submit."));
- }
- errorHtml = "";
- for (i = 0, len = errors.length; i < len; i++) {
- error = errors[i];
- errorHtml = edx.HtmlUtils.joinHtml(
- errorHtml,
- edx.HtmlUtils.interpolateHtml(edx.HtmlUtils.HTML("{error} "), { error: error }),
- );
- }
- errorHtml = edx.HtmlUtils.interpolateHtml(edx.HtmlUtils.HTML(" or (,...)
- var src = {};
- src.period = 0; // Default not periodic
- src.value = function (t) {
- return 0;
- }; // overridden below
- src.inflection_point = function (t) {
- return undefined;
- }; // may be overridden below
-
- // see if there's a "(" in the description
- var index = v.indexOf("(");
- var ch;
- if (index >= 0) {
- src.fun = v.slice(0, index); // function name is before the "("
- src.args = []; // we'll push argument values onto this list
- var end = v.indexOf(")", index);
- if (end == -1) end = v.length;
-
- index += 1; // start parsing right after "("
- while (index < end) {
- // figure out where next argument value starts
- ch = v.charAt(index);
- if (ch <= " ") {
- index++;
- continue;
- }
- // and where it ends
- var arg_end = v.indexOf(",", index);
- if (arg_end == -1) arg_end = end;
- // parse and save result in our list of arg values
- src.args.push(parse_number(v.slice(index, arg_end), undefined));
- index = arg_end + 1;
- }
- } else {
- src.fun = "dc";
- src.args = [parse_number(v, 0)];
- }
-
- // post-processing for constant sources
- // dc(v)
- if (src.fun == "dc") {
- var v = arg_value(src.args, 0, 0);
- src.args = [v];
- src.value = function (t) {
- return v;
- }; // closure
- }
-
- // post-processing for impulse sources
- // impulse(height,width)
- else if (src.fun == "impulse") {
- var h = arg_value(src.args, 0, 1); // default height: 1
- var w = Math.abs(arg_value(src.args, 2, 1e-9)); // default width: 1ns
- src.args = [h, w]; // remember any defaulted values
- pwl_source(src, [0, 0, w / 2, h, w, 0], false);
- }
-
- // post-processing for step sources
- // step(v_init,v_plateau,t_delay,t_rise)
- else if (src.fun == "step") {
- var v1 = arg_value(src.args, 0, 0); // default init value: 0V
- var v2 = arg_value(src.args, 1, 1); // default plateau value: 1V
- var td = Math.max(0, arg_value(src.args, 2, 0)); // time step starts
- var tr = Math.abs(arg_value(src.args, 3, 1e-9)); // default rise time: 1ns
- src.args = [v1, v2, td, tr]; // remember any defaulted values
- pwl_source(src, [td, v1, td + tr, v2], false);
- }
-
- // post-processing for square wave
- // square(v_init,v_plateau,freq,duty_cycle)
- else if (src.fun == "square") {
- var v1 = arg_value(src.args, 0, 0); // default init value: 0V
- var v2 = arg_value(src.args, 1, 1); // default plateau value: 1V
- var freq = Math.abs(arg_value(src.args, 2, 1)); // default frequency: 1Hz
- var duty_cycle = Math.min(100, Math.abs(arg_value(src.args, 3, 50))); // default duty cycle: 0.5
- src.args = [v1, v2, freq, duty_cycle]; // remember any defaulted values
-
- var per = freq == 0 ? Infinity : 1 / freq;
- var t_change = 0.01 * per; // rise and fall time
- var t_pw = 0.01 * duty_cycle * 0.98 * per; // fraction of cycle minus rise and fall time
- pwl_source(src, [0, v1, t_change, v2, t_change + t_pw, v2, t_change + t_pw + t_change, v1, per, v1], true);
- }
-
- // post-processing for triangle
- // triangle(v_init,v_plateua,t_period)
- else if (src.fun == "triangle") {
- var v1 = arg_value(src.args, 0, 0); // default init value: 0V
- var v2 = arg_value(src.args, 1, 1); // default plateau value: 1V
- var freq = Math.abs(arg_value(src.args, 2, 1)); // default frequency: 1s
- src.args = [v1, v2, freq]; // remember any defaulted values
-
- var per = freq == 0 ? Infinity : 1 / freq;
- pwl_source(src, [0, v1, per / 2, v2, per, v1], true);
- }
-
- // post-processing for pwl and pwlr sources
- // pwl[r](t1,v1,t2,v2,...)
- else if (src.fun == "pwl" || src.fun == "pwl_repeating") {
- pwl_source(src, src.args, src.fun == "pwl_repeating");
- }
-
- // post-processing for pulsed sources
- // pulse(v_init,v_plateau,t_delay,t_rise,t_fall,t_width,t_period)
- else if (src.fun == "pulse") {
- var v1 = arg_value(src.args, 0, 0); // default init value: 0V
- var v2 = arg_value(src.args, 1, 1); // default plateau value: 1V
- var td = Math.max(0, arg_value(src.args, 2, 0)); // time pulse starts
- var tr = Math.abs(arg_value(src.args, 3, 1e-9)); // default rise time: 1ns
- var tf = Math.abs(arg_value(src.args, 4, 1e-9)); // default rise time: 1ns
- var pw = Math.abs(arg_value(src.args, 5, 1e9)); // default pulse width: "infinite"
- var per = Math.abs(arg_value(src.args, 6, 1e9)); // default period: "infinite"
- src.args = [v1, v2, td, tr, tf, pw, per];
-
- var t1 = td; // time when v1 -> v2 transition starts
- var t2 = t1 + tr; // time when v1 -> v2 transition ends
- var t3 = t2 + pw; // time when v2 -> v1 transition starts
- var t4 = t3 + tf; // time when v2 -> v1 transition ends
-
- pwl_source(src, [t1, v1, t2, v2, t3, v2, t4, v1, per, v1], true);
- }
-
- // post-processing for sinusoidal sources
- // sin(v_offset,v_amplitude,freq_hz,t_delay,phase_offset_degrees)
- else if (src.fun == "sin") {
- var voffset = arg_value(src.args, 0, 0); // default offset voltage: 0V
- var va = arg_value(src.args, 1, 1); // default amplitude: -1V to 1V
- var freq = Math.abs(arg_value(src.args, 2, 1)); // default frequency: 1Hz
- src.period = 1.0 / freq;
-
- var td = Math.max(0, arg_value(src.args, 3, 0)); // default time delay: 0sec
- var phase = arg_value(src.args, 4, 0); // default phase offset: 0 degrees
- src.args = [voffset, va, freq, td, phase];
-
- phase /= 360.0;
-
- // return value of source at time t
- src.value = function (t) {
- // closure
- if (t < td) return voffset + va * Math.sin(2 * Math.PI * phase);
- else return voffset + va * Math.sin(2 * Math.PI * (freq * (t - td) + phase));
- };
-
- // return time of next inflection point after time t
- src.inflection_point = function (t) {
- // closure
- if (t < td) return td;
- else return undefined;
- };
- }
-
- // object has all the necessary info to compute the source value and inflection points
- src.dc = src.value(0); // DC value is value at time 0
- return src;
- }
-
- function pwl_source(src, tv_pairs, repeat) {
- var nvals = tv_pairs.length;
- if (repeat) src.period = tv_pairs[nvals - 2]; // Repeat period of source
- if (nvals % 2 == 1) npts -= 1; // make sure it's even!
-
- if (nvals <= 2) {
- // handle degenerate case
- src.value = function (t) {
- return nvals == 2 ? tv_pairs[1] : 0;
- };
- src.inflection_point = function (t) {
- return undefined;
- };
- } else {
- src.value = function (t) {
- // closure
- if (repeat)
- // make time periodic if values are to be repeated
- t = Math.fmod(t, tv_pairs[nvals - 2]);
- var last_t = tv_pairs[0];
- var last_v = tv_pairs[1];
- if (t > last_t) {
- var next_t, next_v;
- for (var i = 2; i < nvals; i += 2) {
- next_t = tv_pairs[i];
- next_v = tv_pairs[i + 1];
- if (next_t > last_t)
- if (t < next_t)
- // defend against bogus tv pairs
- return last_v + ((next_v - last_v) * (t - last_t)) / (next_t - last_t);
- last_t = next_t;
- last_v = next_v;
- }
- }
- return last_v;
- };
- src.inflection_point = function (t) {
- // closure
- if (repeat)
- // make time periodic if values are to be repeated
- t = Math.fmod(t, tv_pairs[nvals - 2]);
- for (var i = 0; i < nvals; i += 2) {
- var next_t = tv_pairs[i];
- if (t < next_t) return next_t;
- }
- return undefined;
- };
- }
- }
-
- // helper function: return args[index] if present, else default_v
- function arg_value(args, index, default_v) {
- if (index < args.length) {
- var result = args[index];
- if (result === undefined) result = default_v;
- return result;
- } else return default_v;
- }
-
- // we need fmod in the Math library!
- Math.fmod = function (numerator, denominator) {
- var quotient = Math.floor(numerator / denominator);
- return numerator - quotient * denominator;
- };
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Sources
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- function VSource(npos, nneg, branch, v) {
- Device.call(this);
- this.src = parse_source(v);
- this.npos = npos;
- this.nneg = nneg;
- this.branch = branch;
- }
- VSource.prototype = new Device();
- VSource.prototype.constructor = VSource;
-
- // load linear part for source evaluation
- VSource.prototype.load_linear = function (ckt) {
- // MNA stamp for independent voltage source
- ckt.add_to_Gl(this.branch, this.npos, 1.0);
- ckt.add_to_Gl(this.branch, this.nneg, -1.0);
- ckt.add_to_Gl(this.npos, this.branch, 1.0);
- ckt.add_to_Gl(this.nneg, this.branch, -1.0);
- };
-
- // Source voltage added to b.
- VSource.prototype.load_dc = function (ckt, soln, rhs) {
- ckt.add_to_rhs(this.branch, this.src.dc, rhs);
- };
-
- // Load time-dependent value for voltage source for tran
- VSource.prototype.load_tran = function (ckt, soln, rhs, time) {
- ckt.add_to_rhs(this.branch, this.src.value(time), rhs);
- };
-
- // return time of next breakpoint for the device
- VSource.prototype.breakpoint = function (time) {
- return this.src.inflection_point(time);
- };
-
- // small signal model ac value
- VSource.prototype.load_ac = function (ckt, rhs) {
- ckt.add_to_rhs(this.branch, 1.0, rhs);
- };
-
- function ISource(npos, nneg, v) {
- Device.call(this);
- this.src = parse_source(v);
- this.npos = npos;
- this.nneg = nneg;
- }
- ISource.prototype = new Device();
- ISource.prototype.constructor = ISource;
-
- ISource.prototype.load_linear = function (ckt) {
- // Current source is open when off, no linear contribution
- };
-
- // load linear system equations for dc analysis
- ISource.prototype.load_dc = function (ckt, soln, rhs) {
- var is = this.src.dc;
-
- // MNA stamp for independent current source
- ckt.add_to_rhs(this.npos, -is, rhs); // current flow into npos
- ckt.add_to_rhs(this.nneg, is, rhs); // and out of nneg
- };
-
- // load linear system equations for tran analysis (just like DC)
- ISource.prototype.load_tran = function (ckt, soln, rhs, time) {
- var is = this.src.value(time);
-
- // MNA stamp for independent current source
- ckt.add_to_rhs(this.npos, -is, rhs); // current flow into npos
- ckt.add_to_rhs(this.nneg, is, rhs); // and out of nneg
- };
-
- // return time of next breakpoint for the device
- ISource.prototype.breakpoint = function (time) {
- return this.src.inflection_point(time);
- };
-
- // small signal model: open circuit
- ISource.prototype.load_ac = function (ckt, rhs) {
- // MNA stamp for independent current source
- ckt.add_to_rhs(this.npos, -1.0, rhs); // current flow into npos
- ckt.add_to_rhs(this.nneg, 1.0, rhs); // and out of nneg
- };
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Resistor
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- function Resistor(n1, n2, v) {
- Device.call(this);
- this.n1 = n1;
- this.n2 = n2;
- this.g = 1.0 / v;
- }
- Resistor.prototype = new Device();
- Resistor.prototype.constructor = Resistor;
-
- Resistor.prototype.load_linear = function (ckt) {
- // MNA stamp for admittance g
- ckt.add_conductance_l(this.n1, this.n2, this.g);
- };
-
- Resistor.prototype.load_dc = function (ckt) {
- // Nothing to see here, move along.
- };
-
- Resistor.prototype.load_tran = function (ckt, soln) {};
-
- Resistor.prototype.load_ac = function (ckt) {};
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Diode
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- function Diode(n1, n2, v, type) {
- Device.call(this);
- this.anode = n1;
- this.cathode = n2;
- this.area = v;
- this.type = type; // 'normal' or 'ideal'
- this.is = 1.0e-14;
- this.ais = this.area * this.is;
- this.vt = type == "normal" ? 25.8e-3 : 0.1e-3; // 26mv or .1mv
- this.exp_arg_max = 50; // less than single precision max.
- this.exp_max = Math.exp(this.exp_arg_max);
- }
- Diode.prototype = new Device();
- Diode.prototype.constructor = Diode;
-
- Diode.prototype.load_linear = function (ckt) {
- // Diode is not linear, has no linear piece.
- };
-
- Diode.prototype.load_dc = function (ckt, soln, rhs) {
- var vd = ckt.get_two_terminal(this.anode, this.cathode, soln);
- var exp_arg = vd / this.vt;
- var temp1, temp2;
- // Estimate exponential with a quadratic if arg too big.
- var abs_exp_arg = Math.abs(exp_arg);
- var d_arg = abs_exp_arg - this.exp_arg_max;
- if (d_arg > 0) {
- var quad = 1 + d_arg + 0.5 * d_arg * d_arg;
- temp1 = this.exp_max * quad;
- temp2 = this.exp_max * (1 + d_arg);
- } else {
- temp1 = Math.exp(abs_exp_arg);
- temp2 = temp1;
- }
- if (exp_arg < 0) {
- // Use exp(-x) = 1.0/exp(x)
- temp1 = 1.0 / temp1;
- temp2 = temp1 * temp2 * temp1;
- }
- var id = this.ais * (temp1 - 1);
- var gd = this.ais * (temp2 / this.vt);
-
- // MNA stamp for independent current source
- ckt.add_to_rhs(this.anode, -id, rhs); // current flows into anode
- ckt.add_to_rhs(this.cathode, id, rhs); // and out of cathode
- ckt.add_conductance(this.anode, this.cathode, gd);
- };
-
- Diode.prototype.load_tran = function (ckt, soln, rhs, time) {
- this.load_dc(ckt, soln, rhs);
- };
-
- Diode.prototype.load_ac = function (ckt) {};
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Capacitor
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- function Capacitor(n1, n2, v) {
- Device.call(this);
- this.n1 = n1;
- this.n2 = n2;
- this.value = v;
- }
- Capacitor.prototype = new Device();
- Capacitor.prototype.constructor = Capacitor;
-
- Capacitor.prototype.load_linear = function (ckt) {
- // MNA stamp for capacitance matrix
- ckt.add_capacitance(this.n1, this.n2, this.value);
- };
-
- Capacitor.prototype.load_dc = function (ckt, soln, rhs) {};
-
- Capacitor.prototype.load_ac = function (ckt) {};
-
- Capacitor.prototype.load_tran = function (ckt) {};
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Inductor
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- function Inductor(n1, n2, branch, v) {
- Device.call(this);
- this.n1 = n1;
- this.n2 = n2;
- this.branch = branch;
- this.value = v;
- }
- Inductor.prototype = new Device();
- Inductor.prototype.constructor = Inductor;
-
- Inductor.prototype.load_linear = function (ckt) {
- // MNA stamp for inductor linear part
- // L on diag of C because L di/dt = v(n1) - v(n2)
- ckt.add_to_Gl(this.n1, this.branch, 1);
- ckt.add_to_Gl(this.n2, this.branch, -1);
- ckt.add_to_Gl(this.branch, this.n1, -1);
- ckt.add_to_Gl(this.branch, this.n2, 1);
- ckt.add_to_C(this.branch, this.branch, this.value);
- };
-
- Inductor.prototype.load_dc = function (ckt, soln, rhs) {
- // Inductor is a short at dc, so is linear.
- };
-
- Inductor.prototype.load_ac = function (ckt) {};
-
- Inductor.prototype.load_tran = function (ckt) {};
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Simple Voltage-Controlled Voltage Source Op Amp model
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- function Opamp(np, nn, no, ng, branch, A, name) {
- Device.call(this);
- this.np = np;
- this.nn = nn;
- this.no = no;
- this.ng = ng;
- this.branch = branch;
- this.gain = A;
- this.name = name;
- }
-
- Opamp.prototype = new Device();
- Opamp.prototype.constructor = Opamp;
- Opamp.prototype.load_linear = function (ckt) {
- // MNA stamp for VCVS: 1/A(v(no) - v(ng)) - (v(np)-v(nn))) = 0.
- var invA = 1.0 / this.gain;
- ckt.add_to_Gl(this.no, this.branch, 1);
- ckt.add_to_Gl(this.ng, this.branch, -1);
- ckt.add_to_Gl(this.branch, this.no, invA);
- ckt.add_to_Gl(this.branch, this.ng, -invA);
- ckt.add_to_Gl(this.branch, this.np, -1);
- ckt.add_to_Gl(this.branch, this.nn, 1);
- };
-
- Opamp.prototype.load_dc = function (ckt, soln, rhs) {
- // Op-amp is linear.
- };
-
- Opamp.prototype.load_ac = function (ckt) {};
-
- Opamp.prototype.load_tran = function (ckt) {};
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Simplified MOS FET with no bulk connection and no body effect.
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- function Fet(d, g, s, ratio, name, type) {
- Device.call(this);
- this.d = d;
- this.g = g;
- this.s = s;
- this.name = name;
- this.ratio = ratio;
- if (type != "n" && type != "p") {
- throw "fet type is not n or p";
- }
- this.type_sign = type == "n" ? 1 : -1;
- this.vt = 0.5;
- this.kp = 20e-6;
- this.beta = this.kp * this.ratio;
- this.lambda = 0.05;
- }
- Fet.prototype = new Device();
- Fet.prototype.constructor = Fet;
-
- Fet.prototype.load_linear = function (ckt) {
- // FET's are nonlinear, just like javascript progammers
- };
-
- Fet.prototype.load_dc = function (ckt, soln, rhs) {
- var vds = this.type_sign * ckt.get_two_terminal(this.d, this.s, soln);
- if (vds < 0) {
- // Drain and source have swapped roles
- var temp = this.d;
- this.d = this.s;
- this.s = temp;
- vds = this.type_sign * ckt.get_two_terminal(this.d, this.s, soln);
- }
- var vgs = this.type_sign * ckt.get_two_terminal(this.g, this.s, soln);
- var vgst = vgs - this.vt;
- var gmgs, ids, gds;
- if (vgst > 0.0) {
- // vgst < 0, transistor off, no subthreshold here.
- if (vgst < vds) {
- /* Saturation. */
- gmgs = this.beta * (1 + this.lambda * vds) * vgst;
- ids = this.type_sign * 0.5 * gmgs * vgst;
- gds = 0.5 * this.beta * vgst * vgst * this.lambda;
- } else {
- /* Linear region */
- gmgs = this.beta * (1 + this.lambda * vds);
- ids = this.type_sign * gmgs * vds * (vgst - 0.5 * vds);
- gds = gmgs * (vgst - vds) + this.beta * this.lambda * vds * (vgst - 0.5 * vds);
- gmgs *= vds;
- }
- ckt.add_to_rhs(this.d, -ids, rhs); // current flows into the drain
- ckt.add_to_rhs(this.s, ids, rhs); // and out the source
- ckt.add_conductance(this.d, this.s, gds);
- ckt.add_to_G(this.s, this.s, gmgs);
- ckt.add_to_G(this.d, this.s, -gmgs);
- ckt.add_to_G(this.d, this.g, gmgs);
- ckt.add_to_G(this.s, this.g, -gmgs);
- }
- };
-
- Fet.prototype.load_tran = function (ckt, soln, rhs) {
- this.load_dc(ckt, soln, rhs);
- };
-
- Fet.prototype.load_ac = function (ckt) {};
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Module definition
- //
- ///////////////////////////////////////////////////////////////////////////////
- var module = {
- Circuit: Circuit,
- parse_number: parse_number,
- parse_source: parse_source,
- };
- return module;
-})();
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Simple schematic capture
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// Copyright (C) 2011 Massachusetts Institute of Technology
-
-// add schematics to a document with
-//
-//
-//
-// other attributes you can add to the input tag:
-// width -- width in pixels of diagram
-// height -- height in pixels of diagram
-// parts -- comma-separated list of parts for parts bin (see parts_map),
-// parts="" disables editing of diagram
-
-// JSON schematic representation:
-// sch := [part, part, ...]
-// part := [type, coords, properties, connections]
-// type := string (see parts_map)
-// coords := [number, ...] // (x,y,rot) or (x1,y1,x2,y2)
-// properties := {name: value, ...}
-// connections := [node, ...] // one per connection point in canoncial order
-// node := string
-// need a netlist? just use the part's type, properites and connections
-
-// TO DO:
-// - wire labels?
-// - zoom/scroll canvas
-// - rotate multiple objects around their center of mass
-// - rubber band wires when moving components
-
-// set up each schematic entry widget
-function update_schematics() {
- // set up each schematic on the page
- var schematics = $(".schematic");
- for (var i = 0; i < schematics.length; ++i)
- if (schematics[i].getAttribute("loaded") != "true") {
- try {
- new schematic.Schematic(schematics[i]);
- } catch (err) {
- var msgdiv = document.createElement("div");
- msgdiv.style.border = "thick solid #FF0000";
- msgdiv.style.margins = "20px";
- msgdiv.style.padding = "20px";
- var msg = document.createTextNode(
- "Sorry, there a browser error in starting the schematic tool. The tool is known to be compatible with the latest versions of Firefox and Chrome, which we recommend you use.",
- );
- msgdiv.appendChild(msg);
- schematics[i].parentNode.insertBefore(msgdiv, schematics[i]);
- }
- schematics[i].setAttribute("loaded", "true");
- }
-}
-window.update_schematics = update_schematics;
-
-schematic = (function () {
- var background_style = "rgb(220,220,220)";
- var element_style = "rgb(255,255,255)";
- var thumb_style = "rgb(128,128,128)";
- var normal_style = "rgb(0,0,0)"; // default drawing color
- var component_style = "rgb(64,64,255)"; // color for unselected components
- var selected_style = "rgb(64,255,64)"; // highlight color for selected components
- var grid_style = "rgb(128,128,128)";
- var annotation_style = "rgb(255,64,64)"; // color for diagram annotations
- var property_size = 5; // point size for Component property text
- var annotation_size = 6; // point size for diagram annotations
-
- var parts_map = {
- g: [Ground, "Ground connection"],
- L: [Label, "Node label"],
- v: [VSource, "Voltage source"],
- i: [ISource, "Current source"],
- r: [Resistor, "Resistor"],
- c: [Capacitor, "Capacitor"],
- l: [Inductor, "Inductor"],
- o: [OpAmp, "Op Amp"],
- d: [Diode, "Diode"],
- n: [NFet, "NFet"],
- p: [PFet, "PFet"],
- s: [Probe, "Voltage Probe"],
- a: [Ammeter, "Current Probe"],
- };
-
- // global clipboard
- if (typeof sch_clipboard == "undefined") sch_clipboard = [];
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Schematic = diagram + parts bin + status area
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- // setup a schematic by populating the
{html}
').format(
- id=self.location.html_id(), ajax_url=self.ajax_url, html=HTML(html)
- )
-
- # Now do all the substitutions which the LMS block_render normally does, but
- # we need to do here explicitly since we can get called for our HTML via AJAX
- html = self.runtime.service(self, "replace_urls").replace_urls(html)
-
- return html
-
- def _get_answer_notification(self, render_notifications): # pylint: disable=too-many-branches
- """
- Generate the answer notification type and message from the current problem status.
-
- Arguments:
- render_notifications (bool): If false the method will return an None for type and message
- """
- answer_notification_message = None
- answer_notification_type = None
-
- if render_notifications:
- progress = self.get_progress()
- id_list = list(self.lcp.correct_map.keys())
-
- # Show only a generic message if hiding correctness
- if not self.correctness_available():
- answer_notification_type = "submitted"
- elif len(id_list) == 1:
- # Only one answer available
- answer_notification_type = self.lcp.correct_map.get_correctness(id_list[0])
- elif len(id_list) > 1:
- # Check the multiple answers that are available
- answer_notification_type = self.lcp.correct_map.get_correctness(id_list[0])
- for answer_id in id_list[1:]:
- if self.lcp.correct_map.get_correctness(answer_id) != answer_notification_type:
- # There is at least 1 of the following combinations of correctness states
- # Correct and incorrect, Correct and partially correct, or Incorrect and partially correct
- # which all should have a message type of Partially Correct
- answer_notification_type = "partially-correct"
- break
-
- # Build the notification message based on the notification type and translate it.
- ngettext = self.runtime.service(self, "i18n").ngettext
- _ = self.runtime.service(self, "i18n").gettext
- if answer_notification_type == "incorrect":
- if progress is not None:
- answer_notification_message = ngettext(
- "Incorrect ({progress} point)", "Incorrect ({progress} points)", progress.frac()[1]
- ).format(progress=str(progress))
- else:
- answer_notification_message = _("Incorrect")
- elif answer_notification_type == "correct":
- if progress is not None:
- answer_notification_message = ngettext(
- "Correct ({progress} point)", "Correct ({progress} points)", progress.frac()[1]
- ).format(progress=str(progress))
- else:
- answer_notification_message = _("Correct")
- elif answer_notification_type == "partially-correct":
- if progress is not None:
- answer_notification_message = ngettext(
- "Partially correct ({progress} point)",
- "Partially correct ({progress} points)",
- progress.frac()[1],
- ).format(progress=str(progress))
- else:
- answer_notification_message = _("Partially Correct")
- elif answer_notification_type == "submitted":
- answer_notification_message = _("Answer submitted.")
-
- return answer_notification_type, answer_notification_message
-
- def remove_tags_from_html(self, html):
- """
- The capa xml includes many tags such as Problem Header
- - diff --git a/xmodule/js/fixtures/problem_content_1240.html b/xmodule/js/fixtures/problem_content_1240.html deleted file mode 100644 index 700286b75db1..000000000000 --- a/xmodule/js/fixtures/problem_content_1240.html +++ /dev/null @@ -1,23 +0,0 @@ -Problem Header
- -
-
diff --git a/xmodule/js/spec/capa/display_spec.js b/xmodule/js/spec/capa/display_spec.js
deleted file mode 100644
index f44d3c185168..000000000000
--- a/xmodule/js/spec/capa/display_spec.js
+++ /dev/null
@@ -1,1185 +0,0 @@
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-describe("Problem", function () {
- const problem_content_default = readFixtures("problem_content.html");
-
- beforeEach(function () {
- // Stub MathJax
- window.MathJax = {
- Hub: jasmine.createSpyObj("MathJax.Hub", ["getAllJax", "Queue"]),
- Callback: jasmine.createSpyObj("MathJax.Callback", ["After"]),
- };
- this.stubbedJax = { root: jasmine.createSpyObj("jax.root", ["toMathML"]) };
- MathJax.Hub.getAllJax.and.returnValue([this.stubbedJax]);
- window.update_schematics = function () {};
- spyOn(SR, "readText");
- spyOn(SR, "readTexts");
-
- // Load this function from spec/helper.js
- // Note that if your test fails with a message like:
- // 'External request attempted for blah, which is not defined.'
- // this msg is coming from the stubRequests function else clause.
- jasmine.stubRequests();
-
- loadFixtures("problem.html");
-
- spyOn(Logger, "log");
- spyOn($.fn, "load").and.callFake(function (url, callback) {
- $(this).html(readFixtures("problem_content.html"));
- return callback();
- });
- });
-
- describe("constructor", function () {
- it("set the element from html", function () {
- this.problem999 = new Problem(`\
-${_("Problem Content")}
-
-
-
-
-
-
-
-
-
- Explanation
-
-
-Correctexcellent
Yepcorrect
Incorrectno, try again
'; - spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) { - let promise; - callback({ success: "incorrect", contents }); - promise = { - always(callable) { - return callable(); - }, - done(callable) { - return callable(); - }, - }; - return promise; - }); - this.problem.submit(); - expect(this.problem.el).toHaveHtml(contents); - expect(window.SR.readTexts).toHaveBeenCalledWith(["no, try again"]); - })); - - it("tests if the submit button is disabled while submitting and the text changes on the button", function () { - const self = this; - const curr_html = this.problem.el.html(); - spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) { - // At this point enableButtons should have been called, making the submit button disabled with text 'submitting' - let promise; - expect(self.problem.submitButton).toHaveAttr("disabled"); - expect(self.problem.submitButtonLabel.text()).toBe("Submitting"); - callback({ - success: "incorrect", // does not matter if correct or incorrect here - contents: curr_html, - }); - promise = { - always(callable) { - return callable(); - }, - done(callable) { - return callable(); - }, - }; - return promise; - }); - // Make sure the submit button is enabled before submitting - $("#input_example_1").val("test").trigger("input"); - expect(this.problem.submitButton).not.toHaveAttr("disabled"); - this.problem.submit(); - // After submit, the button should not be disabled and should have text as 'Submit' - expect(this.problem.submitButtonLabel.text()).toBe("Submit"); - expect(this.problem.submitButton).not.toHaveAttr("disabled"); - }); - }); - - describe("submit button on problems", function () { - beforeEach(function () { - this.problem = new Problem($(".xblock-student_view")); - this.submitDisabled = (disabled) => { - if (disabled) { - expect(this.problem.submitButton).toHaveAttr("disabled"); - } else { - expect(this.problem.submitButton).not.toHaveAttr("disabled"); - } - }; - }); - - describe("some basic tests for submit button", () => - it("should become enabled after a value is entered into the text box", function () { - $("#input_example_1").val("test").trigger("input"); - this.submitDisabled(false); - $("#input_example_1").val("").trigger("input"); - this.submitDisabled(true); - })); - - describe("some advanced tests for submit button", function () { - const radioButtonProblemHtml = readFixtures("radiobutton_problem.html"); - const checkboxProblemHtml = readFixtures("checkbox_problem.html"); - - it("should become enabled after a checkbox is checked", function () { - $("#input_example_1").replaceWith(checkboxProblemHtml); - this.problem.submitAnswersAndSubmitButton(true); - this.submitDisabled(true); - $("#input_1_1_1").click(); - this.submitDisabled(false); - $("#input_1_1_1").click(); - this.submitDisabled(true); - }); - - it("should become enabled after a radiobutton is checked", function () { - $("#input_example_1").replaceWith(radioButtonProblemHtml); - this.problem.submitAnswersAndSubmitButton(true); - this.submitDisabled(true); - $("#input_1_1_1").attr("checked", true).trigger("click"); - this.submitDisabled(false); - $("#input_1_1_1").attr("checked", false).trigger("click"); - this.submitDisabled(true); - }); - - it("should become enabled after a value is selected in a selector", function () { - const html = `\ -
-
-
\
-`;
- $("#input_example_1").replaceWith(html);
- this.problem.submitAnswersAndSubmitButton(true);
- this.submitDisabled(true);
- $("#problem_sel select").val("val2").trigger("change");
- this.submitDisabled(false);
- $("#problem_sel select").val("val0").trigger("change");
- this.submitDisabled(true);
- });
-
- it("should become enabled after a radiobutton is checked and a value is entered into the text box", function () {
- $(radioButtonProblemHtml).insertAfter("#input_example_1");
- this.problem.submitAnswersAndSubmitButton(true);
- this.submitDisabled(true);
- $("#input_1_1_1").attr("checked", true).trigger("click");
- this.submitDisabled(true);
- $("#input_example_1").val("111").trigger("input");
- this.submitDisabled(false);
- $("#input_1_1_1").attr("checked", false).trigger("click");
- this.submitDisabled(true);
- });
-
- it("should become enabled if there are only hidden input fields", function () {
- const html = `\
-\
-`;
- $("#input_example_1").replaceWith(html);
- this.problem.submitAnswersAndSubmitButton(true);
- this.submitDisabled(false);
- });
- });
- });
-
- describe("reset", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- });
-
- it("log the problem_reset event", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.answers = "foo=1&bar=2";
- this.problem.reset();
- expect(Logger.log).toHaveBeenCalledWith("problem_reset", "foo=1&bar=2");
- });
-
- it("POST to the problem reset page", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.reset();
- expect($.postWithPrefix).toHaveBeenCalledWith(
- "/problem/Problem1/problem_reset",
- { id: "i4x://edX/101/problem/Problem1" },
- jasmine.any(Function),
- );
- });
-
- it("render the returned content", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- callback({ html: "Reset", success: true });
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.reset();
- expect(this.problem.el.html()).toEqual("Reset");
- });
-
- it("sends a message to the window SR element", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- callback({ html: "Reset", success: true });
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.reset();
- expect(window.SR.readText).toHaveBeenCalledWith("This problem has been reset.");
- });
-
- it("shows a notification on error", function () {
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- let promise;
- callback({ msg: "Error on reset.", success: false });
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- this.problem.reset();
- expect($(".notification-gentle-alert .notification-message").text()).toEqual("Error on reset.");
- });
-
- it("tests that reset does not enable submit or modify the text while resetting", function () {
- const self = this;
- const curr_html = this.problem.el.html();
- spyOn($, "postWithPrefix").and.callFake(function (url, answers, callback) {
- // enableButtons should have been called at this point to set them to all disabled
- let promise;
- expect(self.problem.submitButton).toHaveAttr("disabled");
- expect(self.problem.submitButtonLabel.text()).toBe("Submit");
- callback({ success: "correct", html: curr_html });
- promise = {
- always(callable) {
- return callable();
- },
- };
- return promise;
- });
- // Submit should be disabled
- expect(this.problem.submitButton).toHaveAttr("disabled");
- this.problem.reset();
- // Submit should remain disabled
- expect(self.problem.submitButton).toHaveAttr("disabled");
- expect(self.problem.submitButtonLabel.text()).toBe("Submit");
- });
- });
-
- describe("show problem with column in id", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.el.prepend('');
- });
-
- it("log the problem_show event", function () {
- this.problem.show();
- expect(Logger.log).toHaveBeenCalledWith("problem_show", { problem: "i4x://edX/101/problem/Problem1" });
- });
-
- it("fetch the answers", function () {
- spyOn($, "postWithPrefix");
- this.problem.show();
- expect($.postWithPrefix).toHaveBeenCalledWith("/problem/Problem1/problem_show", jasmine.any(Function));
- });
-
- it("show the answers", function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) =>
- callback({ answers: { "1_1:11": "One", "1_2:12": "Two" } }),
- );
- this.problem.show();
- expect($("#answer_1_1\\:11")).toHaveHtml("One");
- expect($("#answer_1_2\\:12")).toHaveHtml("Two");
- });
-
- it("disables the show answer button", function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) => callback({ answers: {} }));
- this.problem.show();
- expect(this.problem.el.find(".show").attr("disabled")).toEqual("disabled");
- });
- });
-
- describe("show", function () {
- beforeEach(function () {
- this.problem = new Problem($(".xblock-student_view"));
- this.problem.el.prepend('');
- });
-
- describe("when the answer has not yet shown", function () {
- beforeEach(function () {
- expect(this.problem.el.find(".show").attr("disabled")).not.toEqual("disabled");
- });
-
- it("log the problem_show event", function () {
- this.problem.show();
- expect(Logger.log).toHaveBeenCalledWith("problem_show", { problem: "i4x://edX/101/problem/Problem1" });
- });
-
- it("fetch the answers", function () {
- spyOn($, "postWithPrefix");
- this.problem.show();
- expect($.postWithPrefix).toHaveBeenCalledWith("/problem/Problem1/problem_show", jasmine.any(Function));
- });
-
- it("show the answers", function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) =>
- callback({ answers: { "1_1": "One", "1_2": "Two" } }),
- );
- this.problem.show();
- expect($("#answer_1_1")).toHaveHtml("One");
- expect($("#answer_1_2")).toHaveHtml("Two");
- });
-
- it("disables the show answer button", function () {
- spyOn($, "postWithPrefix").and.callFake((url, callback) => callback({ answers: {} }));
- this.problem.show();
- expect(this.problem.el.find(".show").attr("disabled")).toEqual("disabled");
- });
-
- describe("radio text question", function () {
- const radio_text_xml = `\
-- {errors}
with the appropriate children
- function Schematic(input) {
- // set up diagram viewing parameters
- this.show_grid = true;
- this.grid = 8;
- this.scale = 2;
- this.origin_x = input.getAttribute("origin_x");
- if (this.origin_x == undefined) this.origin_x = 0;
- this.origin_y = input.getAttribute("origin_y");
- if (this.origin_y == undefined) this.origin_y = 0;
- this.cursor_x = 0;
- this.cursor_y = 0;
- this.window_list = []; // list of pop-up windows in increasing z order
-
- // use user-supplied list of parts if supplied
- // else just populate parts bin with all the parts
- this.edits_allowed = true;
- var parts = input.getAttribute("parts");
- if (parts == undefined || parts == "None") {
- parts = [];
- for (var p in parts_map) parts.push(p);
- } else if (parts == "") {
- this.edits_allowed = false;
- parts = [];
- } else parts = parts.split(",");
-
- // now add the parts to the parts bin
- this.parts_bin = [];
- for (var i = 0; i < parts.length; i++) {
- var part = new Part(this);
- var pm = parts_map[parts[i]];
- part.set_component(new pm[0](0, 0, 0), pm[1]);
- this.parts_bin.push(part);
- }
-
- // use user-supplied list of analyses, otherwise provide them all
- // analyses="" means no analyses
- var analyses = input.getAttribute("analyses");
- if (analyses == undefined || analyses == "None") analyses = ["dc", "ac", "tran"];
- else if (analyses == "") analyses = [];
- else analyses = analyses.split(",");
-
- if (parts.length == 0 && analyses.length == 0) this.diagram_only = true;
- else this.diagram_only = false;
-
- // see what we need to submit. Expecting attribute of the form
- // submit_analyses="{'tran':[[node_name,t1,t2,t3],...],
- // 'ac':[[node_name,f1,f2,...],...]}"
- var submit = input.getAttribute("submit_analyses");
- if (submit && submit.indexOf("{") != -1) this.submit_analyses = JSON.parse(submit);
- else this.submit_analyses = undefined;
-
- // toolbar
- this.tools = [];
- this.toolbar = [];
-
- /* DISABLE HELP BUTTON (target URL not consistent with multicourse hierarchy) -- SJSU
- if (!this.diagram_only) {
- this.tools['help'] = this.add_tool(help_icon,'Help: display help page',this.help);
- this.enable_tool('help',true);
- this.toolbar.push(null); // spacer
- }
- END DISABLE HELP BUTTON -- SJSU */
-
- if (this.edits_allowed) {
- this.tools["grid"] = this.add_tool(grid_icon, "Grid: toggle grid display", this.toggle_grid);
- this.enable_tool("grid", true);
- this.tools["cut"] = this.add_tool(
- cut_icon,
- "Cut: move selected components from diagram to the clipboard",
- this.cut,
- );
- this.tools["copy"] = this.add_tool(copy_icon, "Copy: copy selected components into the clipboard", this.copy);
- this.tools["paste"] = this.add_tool(paste_icon, "Paste: copy clipboard into the diagram", this.paste);
- this.toolbar.push(null); // spacer
- }
-
- // simulation interface if cktsim.js is loaded
- if (typeof cktsim != "undefined") {
- if (analyses.indexOf("dc") != -1) {
- this.tools["dc"] = this.add_tool("DC", "DC Analysis", this.dc_analysis);
- this.enable_tool("dc", true);
- this.dc_max_iters = "1000"; // default values dc solution
- }
-
- if (analyses.indexOf("ac") != -1) {
- this.tools["ac"] = this.add_tool("AC", "AC Small-Signal Analysis", this.setup_ac_analysis);
- this.enable_tool("ac", true);
- this.ac_npts = "50"; // default values for AC Analysis
- this.ac_fstart = "10";
- this.ac_fstop = "1G";
- this.ac_source_name = undefined;
- }
-
- if (analyses.indexOf("tran") != -1) {
- this.tools["tran"] = this.add_tool("TRAN", "Transient Analysis", this.transient_analysis);
- this.enable_tool("tran", true);
- this.tran_npts = "100"; // default values for transient analysis
- this.tran_tstop = "1";
- }
- }
-
- // set up diagram canvas
- this.canvas = document.createElement("canvas");
- this.width = input.getAttribute("width");
- this.width = parseInt(this.width == undefined ? "400" : this.width);
- this.canvas.width = this.width;
- this.height = input.getAttribute("height");
- this.height = parseInt(this.height == undefined ? "300" : this.height);
- this.canvas.height = this.height;
-
- this.sctl_r = 16; // scrolling control parameters
- this.sctl_x = this.sctl_r + 8; // upper left
- this.sctl_y = this.sctl_r + 8;
- this.zctl_left = this.sctl_x - 8;
- this.zctl_top = this.sctl_y + this.sctl_r + 8;
-
- // repaint simply draws this buffer and then adds selected elements on top
- this.bg_image = document.createElement("canvas");
- this.bg_image.width = this.width;
- this.bg_image.height = this.height;
-
- if (!this.diagram_only) {
- this.canvas.tabIndex = 0; // so we get keystrokes
- this.canvas.style.borderStyle = "solid";
- this.canvas.style.borderWidth = "1px";
- this.canvas.style.borderColor = grid_style;
- this.canvas.style.outline = "none";
- }
-
- this.canvas.schematic = this;
- if (this.edits_allowed) {
- this.canvas.addEventListener("mousemove", schematic_mouse_move, false);
- this.canvas.addEventListener("mouseover", schematic_mouse_enter, false);
- this.canvas.addEventListener("mouseout", schematic_mouse_leave, false);
- this.canvas.addEventListener("mousedown", schematic_mouse_down, false);
- this.canvas.addEventListener("mouseup", schematic_mouse_up, false);
- this.canvas.addEventListener("mousewheel", schematic_mouse_wheel, false);
- this.canvas.addEventListener("DOMMouseScroll", schematic_mouse_wheel, false); // for FF
- this.canvas.addEventListener("dblclick", schematic_double_click, false);
- this.canvas.addEventListener("keydown", schematic_key_down, false);
- this.canvas.addEventListener("keyup", schematic_key_up, false);
- }
-
- // set up message area
- if (!this.diagram_only) {
- this.status_div = document.createElement("div");
- this.status = document.createTextNode("");
- this.status_div.appendChild(this.status);
- this.status_div.style.height = status_height + "px";
- } else this.status_div = undefined;
-
- this.connection_points = []; // location string => list of cp's
- this.components = [];
- this.dragging = false;
- this.select_rect = undefined;
- this.wire = undefined;
- this.operating_point = undefined; // result from DC analysis
- this.dc_results = undefined; // saved analysis results for submission
- this.ac_results = undefined; // saved analysis results for submission
- this.transient_results = undefined; // saved analysis results for submission
-
- // state of modifier keys
- this.ctrlKey = false;
- this.shiftKey = false;
- this.altKey = false;
- this.cmdKey = false;
-
- // make sure other code can find us!
- input.schematic = this;
- this.input = input;
-
- // set up DOM -- use nested tables to do the layout
- var table, tr, td;
- table = document.createElement("table");
- table.rules = "none";
- if (!this.diagram_only) {
- table.frame = "box";
- table.style.borderStyle = "solid";
- table.style.borderWidth = "2px";
- table.style.borderColor = normal_style;
- table.style.backgroundColor = background_style;
- }
-
- // add tools to DOM
- if (this.toolbar.length > 0) {
- tr = document.createElement("tr");
- table.appendChild(tr);
- td = document.createElement("td");
- td.style.verticalAlign = "top";
- td.colSpan = 2;
- tr.appendChild(td);
- for (var i = 0; i < this.toolbar.length; ++i) {
- var tool = this.toolbar[i];
- if (tool != null) td.appendChild(tool);
- }
- }
-
- // add canvas and parts bin to DOM
- tr = document.createElement("tr");
- table.appendChild(tr);
-
- td = document.createElement("td");
- tr.appendChild(td);
- var wrapper = document.createElement("div"); // for inserting pop-up windows
- td.appendChild(wrapper);
- wrapper.style.position = "relative"; // so we can position subwindows
- wrapper.appendChild(this.canvas);
-
- td = document.createElement("td");
- td.style.verticalAlign = "top";
- tr.appendChild(td);
- var parts_table = document.createElement("table");
- td.appendChild(parts_table);
- parts_table.rules = "none";
- parts_table.frame = "void";
- parts_table.cellPadding = "0";
- parts_table.cellSpacing = "0";
-
- // fill in parts_table
- var parts_per_column = Math.floor(this.height / (part_h + 5)); // mysterious extra padding
- for (var i = 0; i < parts_per_column; ++i) {
- tr = document.createElement("tr");
- parts_table.appendChild(tr);
- for (var j = i; j < this.parts_bin.length; j += parts_per_column) {
- td = document.createElement("td");
- tr.appendChild(td);
- td.appendChild(this.parts_bin[j].canvas);
- }
- }
-
- if (this.status_div != undefined) {
- tr = document.createElement("tr");
- table.appendChild(tr);
- td = document.createElement("td");
- tr.appendChild(td);
- td.colSpan = 2;
- td.appendChild(this.status_div);
- }
-
- // add to dom
- // avoid Chrome bug that changes to text cursor whenever
- // drag starts. Just do this in schematic tool...
- var toplevel = document.createElement("div");
- toplevel.onselectstart = function () {
- return false;
- };
- toplevel.appendChild(table);
- this.input.parentNode.insertBefore(toplevel, this.input.nextSibling);
-
- // process initial contents of diagram
- this.load_schematic(this.input.getAttribute("value"), this.input.getAttribute("initial_value"));
-
- // start by centering diagram on the screen
- this.zoomall();
- }
-
- var part_w = 42; // size of a parts bin compartment
- var part_h = 42;
- var status_height = 18;
-
- Schematic.prototype.add_component = function (new_c) {
- this.components.push(new_c);
- // create undoable edit record here
- };
-
- Schematic.prototype.remove_component = function (c) {
- var index = this.components.indexOf(c);
- if (index != -1) this.components.splice(index, 1);
- };
-
- Schematic.prototype.find_connections = function (cp) {
- return this.connection_points[cp.location];
- };
-
- Schematic.prototype.add_connection_point = function (cp) {
- var cplist = this.connection_points[cp.location];
- if (cplist) cplist.push(cp);
- else {
- cplist = [cp];
- this.connection_points[cp.location] = cplist;
- }
-
- return cplist;
- };
-
- Schematic.prototype.remove_connection_point = function (cp, old_location) {
- // remove cp from list at old location
- var cplist = this.connection_points[old_location];
- if (cplist) {
- var index = cplist.indexOf(cp);
- if (index != -1) {
- cplist.splice(index, 1);
- // if no more connections at this location, remove
- // entry from array to keep our search time short
- if (cplist.length == 0) delete this.connection_points[old_location];
- }
- }
- };
-
- Schematic.prototype.update_connection_point = function (cp, old_location) {
- this.remove_connection_point(cp, old_location);
- return this.add_connection_point(cp);
- };
-
- Schematic.prototype.add_wire = function (x1, y1, x2, y2) {
- var new_wire = new Wire(x1, y1, x2, y2);
- new_wire.add(this);
- new_wire.move_end();
- return new_wire;
- };
-
- Schematic.prototype.split_wire = function (w, cp) {
- // remove bisected wire
- w.remove();
-
- // add two new wires with connection point cp in the middle
- this.add_wire(w.x, w.y, cp.x, cp.y);
- this.add_wire(w.x + w.dx, w.y + w.dy, cp.x, cp.y);
- };
-
- // see if connection points of component c split any wires
- Schematic.prototype.check_wires = function (c) {
- for (var i = 0; i < this.components.length; i++) {
- var cc = this.components[i];
- if (cc != c) {
- // don't check a component against itself
- // only wires will return non-null from a bisect call
- var cp = cc.bisect(c);
- if (cp) {
- // cc is a wire bisected by connection point cp
- this.split_wire(cc, cp);
- this.redraw_background();
- }
- }
- }
- };
-
- // see if there are any existing connection points that bisect wire w
- Schematic.prototype.check_connection_points = function (w) {
- for (var locn in this.connection_points) {
- var cplist = this.connection_points[locn];
- if (cplist && w.bisect_cp(cplist[0])) {
- this.split_wire(w, cplist[0]);
- this.redraw_background();
-
- // stop here, new wires introduced by split will do their own checks
- return;
- }
- }
- };
-
- // merge collinear wires sharing an end point
- Schematic.prototype.clean_up_wires = function () {
- for (var locn in this.connection_points) {
- var cplist = this.connection_points[locn];
- if (cplist && cplist.length == 2) {
- // found a connection with just two connections, see if they're wires
- var c1 = cplist[0].parent;
- var c2 = cplist[1].parent;
- if (c1.type == "w" && c2.type == "w") {
- var e1 = c1.other_end(cplist[0]);
- var e2 = c2.other_end(cplist[1]);
- var e3 = cplist[0]; // point shared by the two wires
- if (collinear(e1, e2, e3)) {
- c1.remove();
- c2.remove();
- this.add_wire(e1.x, e1.y, e2.x, e2.y);
- }
- }
- }
- }
- };
-
- Schematic.prototype.unselect_all = function (which) {
- this.operating_point = undefined; // remove annotations
- for (var i = this.components.length - 1; i >= 0; --i) if (i != which) this.components[i].set_select(false);
- };
-
- Schematic.prototype.drag_begin = function () {
- // let components know they're about to move
- for (var i = this.components.length - 1; i >= 0; --i) {
- var component = this.components[i];
- if (component.selected) component.move_begin();
- }
-
- // remember where drag started
- this.drag_x = this.cursor_x;
- this.drag_y = this.cursor_y;
- this.dragging = true;
- };
-
- Schematic.prototype.drag_end = function () {
- // let components know they're done moving
- for (var i = this.components.length - 1; i >= 0; --i) {
- var component = this.components[i];
- if (component.selected) component.move_end();
- }
- this.dragging = false;
- this.clean_up_wires();
- this.redraw_background();
- };
-
- Schematic.prototype.help = function () {
- window.open("/static/handouts/schematic_tutorial.pdf");
- };
-
- // zoom diagram around given coords
- Schematic.prototype.rescale = function (nscale, cx, cy) {
- if (cx == undefined) {
- // use current center point if no point has been specified
- cx = this.origin_x + this.width / (2 * this.scale);
- cy = this.origin_y + this.height / (2 * this.scale);
- }
-
- this.origin_x += cx * (this.scale - nscale);
- this.origin_y += cy * (this.scale - nscale);
- this.scale = nscale;
- this.redraw_background();
- };
-
- Schematic.prototype.toggle_grid = function () {
- this.show_grid = !this.show_grid;
- this.redraw_background();
- };
-
- var zoom_factor = 1.25; // scaling is some power of zoom_factor
- var zoom_min = 0.5;
- var zoom_max = 4.0;
- var origin_min = -200; // in grids
- var origin_max = 200;
-
- Schematic.prototype.zoomin = function () {
- var nscale = this.scale * zoom_factor;
- if (nscale < zoom_max) {
- // keep center of view unchanged
- this.origin_x += (this.width / 2) * (1.0 / this.scale - 1.0 / nscale);
- this.origin_y += (this.height / 2) * (1.0 / this.scale - 1.0 / nscale);
- this.scale = nscale;
- this.redraw_background();
- }
- };
-
- Schematic.prototype.zoomout = function () {
- var nscale = this.scale / zoom_factor;
- if (nscale > zoom_min) {
- // keep center of view unchanged
- this.origin_x += (this.width / 2) * (1.0 / this.scale - 1.0 / nscale);
- this.origin_y += (this.height / 2) * (1.0 / this.scale - 1.0 / nscale);
- this.scale = nscale;
- this.redraw_background();
- }
- };
-
- Schematic.prototype.zoomall = function () {
- // w,h for schematic including a 25% margin on all sides
- var sch_w = 1.5 * (this.bbox[2] - this.bbox[0]);
- var sch_h = 1.5 * (this.bbox[3] - this.bbox[1]);
-
- if (sch_w == 0 && sch_h == 0) {
- this.origin_x = 0;
- this.origin_y = 0;
- this.scale = 2;
- } else {
- // compute scales that would make schematic fit, choose smallest
- var scale_x = this.width / sch_w;
- var scale_y = this.height / sch_h;
- this.scale = Math.pow(zoom_factor, Math.ceil(Math.log(Math.min(scale_x, scale_y)) / Math.log(zoom_factor)));
- if (this.scale < zoom_min) this.scale = zoom_min;
- else if (this.scale > zoom_max) this.scale = zoom_max;
-
- // center the schematic
- this.origin_x = (this.bbox[2] + this.bbox[0]) / 2 - this.width / (2 * this.scale);
- this.origin_y = (this.bbox[3] + this.bbox[1]) / 2 - this.height / (2 * this.scale);
- }
-
- this.redraw_background();
- };
-
- Schematic.prototype.cut = function () {
- // clear previous contents
- sch_clipboard = [];
-
- // look for selected components, move them to clipboard.
- for (var i = this.components.length - 1; i >= 0; --i) {
- var c = this.components[i];
- if (c.selected) {
- c.remove();
- sch_clipboard.push(c);
- }
- }
-
- // update diagram view
- this.redraw();
- };
-
- Schematic.prototype.copy = function () {
- // clear previous contents
- sch_clipboard = [];
-
- // look for selected components, copy them to clipboard.
- for (var i = this.components.length - 1; i >= 0; --i) {
- var c = this.components[i];
- if (c.selected) sch_clipboard.push(c.clone(c.x, c.y));
- }
- };
-
- Schematic.prototype.paste = function () {
- // compute left,top of bounding box for origins of
- // components in the clipboard
- var left = undefined;
- var top = undefined;
- for (var i = sch_clipboard.length - 1; i >= 0; --i) {
- var c = sch_clipboard[i];
- left = left ? Math.min(left, c.x) : c.x;
- top = top ? Math.min(top, c.y) : c.y;
- }
-
- this.message("cursor " + this.cursor_x + "," + this.cursor_y);
-
- // clear current selections
- this.unselect_all(-1);
- this.redraw_background(); // so we see any components that got unselected
-
- // make clones of components on the clipboard, positioning
- // them relative to the cursor
- for (var i = sch_clipboard.length - 1; i >= 0; --i) {
- var c = sch_clipboard[i];
- var new_c = c.clone(this.cursor_x + (c.x - left), this.cursor_y + (c.y - top));
- new_c.set_select(true);
- new_c.add(this);
- }
-
- this.redraw();
- };
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Netlist and Simulation interface
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- // load diagram from JSON representation
- Schematic.prototype.load_schematic = function (value, initial_value) {
- // use default value if no schematic info in value
- if (value == undefined || value.indexOf("[") == -1) value = initial_value;
- if (value && value.indexOf("[") != -1) {
- // convert string value into data structure
- var json = JSON.parse(value);
-
- // top level is a list of components
- for (var i = json.length - 1; i >= 0; --i) {
- var c = json[i];
- if (c[0] == "view") {
- this.ac_fstart = c[5];
- this.ac_fstop = c[6];
- this.ac_source_name = c[7];
- this.tran_npts = c[8];
- this.tran_tstop = c[9];
- this.dc_max_iters = c[10];
- } else if (c[0] == "w") {
- // wire
- this.add_wire(c[1][0], c[1][1], c[1][2], c[1][3]);
- } else if (c[0] == "dc") {
- this.dc_results = c[1];
- } else if (c[0] == "transient") {
- this.transient_results = c[1];
- } else if (c[0] == "ac") {
- this.ac_results = c[1];
- } else {
- // ordinary component
- // c := [type, coords, properties, connections]
- var type = c[0];
- var coords = c[1];
- var properties = c[2];
-
- var part = new parts_map[type][0](coords[0], coords[1], coords[2]);
- for (var name in properties) part.properties[name] = properties[name];
-
- part.add(this);
- }
- }
- }
-
- this.redraw_background();
- };
-
- // label all the nodes in the circuit
- Schematic.prototype.label_connection_points = function () {
- // start by clearing all the connection point labels
- for (var i = this.components.length - 1; i >= 0; --i) this.components[i].clear_labels();
-
- // components are in charge of labeling their unlabeled connections.
- // labels given to connection points will propagate to coincident connection
- // points and across Wires.
-
- // let special components like GND label their connection(s)
- for (var i = this.components.length - 1; i >= 0; --i) this.components[i].add_default_labels();
-
- // now have components generate labels for unlabeled connections
- this.next_label = 0;
- for (var i = this.components.length - 1; i >= 0; --i) this.components[i].label_connections();
- };
-
- Schematic.prototype.get_next_label = function () {
- // generate next label in sequence
- this.next_label += 1;
- return this.next_label.toString();
- };
-
- // propagate label to coincident connection points
- Schematic.prototype.propagate_label = function (label, location) {
- var cplist = this.connection_points[location];
- for (var i = cplist.length - 1; i >= 0; --i) cplist[i].propagate_label(label);
- };
-
- // update the value field of our corresponding input field with JSON
- // representation of schematic
- Schematic.prototype.update_value = function () {
- // label connection points
- this.label_connection_points();
-
- // build JSON data structure, convert to string value for
- // input field
- this.input.value = JSON.stringify(this.json_with_analyses());
- };
-
- Schematic.prototype.json = function () {
- var json = [];
-
- // output all the components/wires in the diagram
- var n = this.components.length;
- for (var i = 0; i < n; i++) json.push(this.components[i].json(i));
-
- // capture the current view parameters
- json.push([
- "view",
- this.origin_x,
- this.origin_y,
- this.scale,
- this.ac_npts,
- this.ac_fstart,
- this.ac_fstop,
- this.ac_source_name,
- this.tran_npts,
- this.tran_tstop,
- this.dc_max_iters,
- ]);
-
- return json;
- };
-
- Schematic.prototype.json_with_analyses = function () {
- var json = this.json();
-
- if (this.dc_results != undefined) json.push(["dc", this.dc_results]);
- if (this.ac_results != undefined) json.push(["ac", this.ac_results]);
- if (this.transient_results != undefined) json.push(["transient", this.transient_results]);
-
- return json;
- };
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Simulation interface
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- Schematic.prototype.extract_circuit = function () {
- // give all the circuit nodes a name, extract netlist
- this.label_connection_points();
- var netlist = this.json();
-
- // since we've done the heavy lifting, update input field value
- // so user can grab diagram if they want
- this.input.value = JSON.stringify(netlist);
-
- // create a circuit from the netlist
- var ckt = new cktsim.Circuit();
- if (ckt.load_netlist(netlist)) return ckt;
- else return null;
- };
-
- Schematic.prototype.dc_analysis = function () {
- // remove any previous annotations
- this.unselect_all(-1);
- this.redraw_background();
-
- var ckt = this.extract_circuit();
- if (ckt === null) return;
-
- // run the analysis
- this.operating_point = ckt.dc();
-
- if (this.operating_point != undefined) {
- // save a copy of the results for submission
- this.dc_results = {};
- for (var i in this.operating_point) this.dc_results[i] = this.operating_point[i];
-
- // display results on diagram
- this.redraw();
- }
- };
-
- // return a list of [color,node_label,offset,type] for each probe in the diagram
- // type == 'voltage' or 'current'
- Schematic.prototype.find_probes = function () {
- var result = [];
- var result = [];
- for (var i = this.components.length - 1; i >= 0; --i) {
- var c = this.components[i];
- var info = c.probe_info();
- if (info != undefined) result.push(c.probe_info());
- }
- return result;
- };
-
- // use a dialog to get AC analysis parameters
- Schematic.prototype.setup_ac_analysis = function () {
- this.unselect_all(-1);
- this.redraw_background();
-
- var npts_lbl = "Number of points/decade";
- var fstart_lbl = "Starting frequency (Hz)";
- var fstop_lbl = "Ending frequency (Hz)";
- var source_name_lbl = "Name of V or I source for ac";
-
- if (this.find_probes().length == 0) {
- alert("AC Analysis: there are no voltage probes in the diagram!");
- return;
- }
-
- var fields = [];
- fields[fstart_lbl] = build_input("text", 10, this.ac_fstart);
- fields[fstop_lbl] = build_input("text", 10, this.ac_fstop);
- fields[source_name_lbl] = build_input("text", 10, this.ac_source_name);
-
- var content = build_table(fields);
- content.fields = fields;
- content.sch = this;
-
- this.dialog("AC Analysis", content, function (content) {
- var sch = content.sch;
-
- // retrieve parameters, remember for next time
- sch.ac_fstart = content.fields[fstart_lbl].value;
- sch.ac_fstop = content.fields[fstop_lbl].value;
- sch.ac_source_name = content.fields[source_name_lbl].value;
-
- sch.ac_analysis(
- cktsim.parse_number(sch.ac_npts),
- cktsim.parse_number(sch.ac_fstart),
- cktsim.parse_number(sch.ac_fstop),
- sch.ac_source_name,
- );
- });
- };
-
- Schematic.prototype.ac_analysis = function (npts, fstart, fstop, ac_source_name) {
- var ckt = this.extract_circuit();
- if (ckt === null) return;
- var results = ckt.ac(npts, fstart, fstop, ac_source_name);
-
- if (typeof results == "string") this.message(results);
- else {
- var x_values = results["_frequencies_"];
-
- // x axis will be a log scale
- for (var i = x_values.length - 1; i >= 0; --i) x_values[i] = Math.log(x_values[i]) / Math.LN10;
-
- if (this.submit_analyses != undefined) {
- var submit = this.submit_analyses["ac"];
- if (submit != undefined) {
- // save a copy of the results for submission
- this.ac_results = {};
-
- // save requested values for each requested node
- for (var j = 0; j < submit.length; j++) {
- var flist = submit[j]; // [node_name,f1,f2,...]
- var node = flist[0];
- var values = results[node];
- var fvlist = [];
- // for each requested freq, interpolate response value
- for (var k = 1; k < flist.length; k++) {
- var f = flist[k];
- var v = interpolate(f, x_values, values);
- // convert to dB
- fvlist.push([f, v == undefined ? "undefined" : (20.0 * Math.log(v)) / Math.LN10]);
- }
- // save results as list of [f,response] paris
- this.ac_results[node] = fvlist;
- }
- }
- }
-
- // set up plot values for each node with a probe
- var y_values = []; // list of [color, result_array]
- var z_values = []; // list of [color, result_array]
- var probes = this.find_probes();
- var probe_maxv = [];
- var probe_color = [];
-
- // Check for probe with near zero transfer function and warn
- for (var i = probes.length - 1; i >= 0; --i) {
- if (probes[i][3] != "voltage") continue;
- probe_color[i] = probes[i][0];
- var label = probes[i][1];
- var v = results[label];
- probe_maxv[i] = array_max(v); // magnitudes always > 0
- }
-
- var all_max = array_max(probe_maxv);
- if (all_max < 1.0e-16) {
- alert("Zero ac response, -infinity on DB scale.");
- } else {
- for (var i = probes.length - 1; i >= 0; --i) {
- if (probes[i][3] != "voltage") continue;
- if (probe_maxv[i] / all_max < 1.0e-10) {
- alert("Near zero ac response, remove " + probe_color[i] + " probe");
- return;
- }
- }
- }
-
- for (var i = probes.length - 1; i >= 0; --i) {
- if (probes[i][3] != "voltage") continue;
- var color = probes[i][0];
- var label = probes[i][1];
- var offset = cktsim.parse_number(probes[i][2]);
- var v = results[label];
- // convert values into dB relative to source amplitude
- var v_max = 1;
- for (var j = v.length - 1; j >= 0; --j)
- // convert each value to dB relative to max
- v[j] = (20.0 * Math.log(v[j] / v_max)) / Math.LN10;
- y_values.push([color, offset, v]);
-
- var v = results[label + "_phase"];
- z_values.push([color, 0, v]);
- }
-
- // graph the result and display in a window
- var graph2 = this.graph(x_values, "log(Frequency in Hz)", z_values, "degrees");
- this.window("AC Analysis - Phase", graph2);
- var graph1 = this.graph(x_values, "log(Frequency in Hz)", y_values, "dB");
- this.window("AC Analysis - Magnitude", graph1, 50);
- }
- };
-
- Schematic.prototype.transient_analysis = function () {
- this.unselect_all(-1);
- this.redraw_background();
-
- var npts_lbl = "Minimum number of timepoints";
- var tstop_lbl = "Stop Time (seconds)";
- var probes = this.find_probes();
- if (probes.length == 0) {
- alert("Transient Analysis: there are no probes in the diagram!");
- return;
- }
-
- var fields = [];
- fields[tstop_lbl] = build_input("text", 10, this.tran_tstop);
-
- var content = build_table(fields);
- content.fields = fields;
- content.sch = this;
-
- this.dialog("Transient Analysis", content, function (content) {
- var sch = content.sch;
- var ckt = sch.extract_circuit();
- if (ckt === null) return;
-
- // retrieve parameters, remember for next time
- sch.tran_tstop = content.fields[tstop_lbl].value;
-
- // gather a list of nodes that are being probed. These
- // will be added to the list of nodes checked during the
- // LTE calculations in transient analysis
- var probe_list = sch.find_probes();
- var probe_names = new Array(probe_list.length);
- for (var i = probe_list.length - 1; i >= 0; --i) probe_names[i] = probe_list[i][1];
-
- // run the analysis
- var results = ckt.tran(ckt.parse_number(sch.tran_npts), 0, ckt.parse_number(sch.tran_tstop), probe_names, false);
-
- if (typeof results == "string") sch.message(results);
- else {
- if (sch.submit_analyses != undefined) {
- var submit = sch.submit_analyses["tran"];
- if (submit != undefined) {
- // save a copy of the results for submission
- sch.transient_results = {};
- var times = results["_time_"];
-
- // save requested values for each requested node
- for (var j = 0; j < submit.length; j++) {
- var tlist = submit[j]; // [node_name,t1,t2,...]
- var node = tlist[0];
- var values = results[node];
- var tvlist = [];
- // for each requested time, interpolate waveform value
- for (var k = 1; k < tlist.length; k++) {
- var t = tlist[k];
- var v = interpolate(t, times, values);
- tvlist.push([t, v == undefined ? "undefined" : v]);
- }
- // save results as list of [t,value] pairs
- sch.transient_results[node] = tvlist;
- }
- }
- }
-
- var x_values = results["_time_"];
- var x_legend = "Time";
-
- // set up plot values for each node with a probe
- var v_values = []; // voltage values: list of [color, result_array]
- var i_values = []; // current values: list of [color, result_array]
- var probes = sch.find_probes();
-
- for (var i = probes.length - 1; i >= 0; --i) {
- var color = probes[i][0];
- var label = probes[i][1];
- var offset = cktsim.parse_number(probes[i][2]);
- var v = results[label];
- if (v == undefined) {
- alert(
- "The " +
- color +
- " probe is connected to node " +
- '"' +
- label +
- '"' +
- " which is not an actual circuit node",
- );
- } else if (probes[i][3] == "voltage") {
- if (color == "x-axis") {
- x_values = v;
- x_legend = "Voltage";
- } else v_values.push([color, offset, v]);
- } else {
- if (color == "x-axis") {
- x_values = v;
- x_legend = "Current";
- } else i_values.push([color, offset, v]);
- }
- }
-
- // graph the result and display in a window
- var graph = sch.graph(x_values, x_legend, v_values, "Voltage", i_values, "Current");
- sch.window("Results of Transient Analysis", graph);
- }
- });
- };
-
- // t is the time at which we want a value
- // times is a list of timepoints from the simulation
- function interpolate(t, times, values) {
- if (values == undefined) return undefined;
-
- for (var i = 0; i < times.length; i++)
- if (t < times[i]) {
- // t falls between times[i-1] and times[i]
- var t1 = i == 0 ? times[0] : times[i - 1];
- var t2 = times[i];
-
- if (t2 == undefined) return undefined;
-
- var v1 = i == 0 ? values[0] : values[i - 1];
- var v2 = values[i];
- var v = v1;
- if (t != t1) v += ((t - t1) * (v2 - v1)) / (t2 - t1);
- return v;
- }
- }
-
- // external interface for setting the property value of a named component
- Schematic.prototype.set_property = function (component_name, property, value) {
- this.unselect_all(-1);
-
- for (var i = this.components.length - 1; i >= 0; --i) {
- var component = this.components[i];
- if (component.properties["name"] == component_name) {
- component.properties[property] = value.toString();
- break;
- }
- }
-
- this.redraw_background();
- };
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Drawing support -- deals with scaling and scrolling of diagrama
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- // here to redraw background image containing static portions of the schematic.
- // Also redraws dynamic portion.
- Schematic.prototype.redraw_background = function () {
- var c = this.bg_image.getContext("2d");
-
- c.lineCap = "round";
-
- // paint background color
- c.fillStyle = element_style;
- c.fillRect(0, 0, this.width, this.height);
-
- if (!this.diagram_only && this.show_grid) {
- // grid
- c.strokeStyle = grid_style;
- var first_x = this.origin_x;
- var last_x = first_x + this.width / this.scale;
- var first_y = this.origin_y;
- var last_y = first_y + this.height / this.scale;
-
- for (var i = this.grid * Math.ceil(first_x / this.grid); i < last_x; i += this.grid)
- this.draw_line(c, i, first_y, i, last_y, 0.1);
-
- for (var i = this.grid * Math.ceil(first_y / this.grid); i < last_y; i += this.grid)
- this.draw_line(c, first_x, i, last_x, i, 0.1);
- }
-
- // unselected components
- var min_x = Infinity; // compute bounding box for diagram
- var max_x = -Infinity;
- var min_y = Infinity;
- var max_y = -Infinity;
- for (var i = this.components.length - 1; i >= 0; --i) {
- var component = this.components[i];
- if (!component.selected) {
- component.draw(c);
- min_x = Math.min(component.bbox[0], min_x);
- max_x = Math.max(component.bbox[2], max_x);
- min_y = Math.min(component.bbox[1], min_y);
- max_y = Math.max(component.bbox[3], max_y);
- }
- }
- this.unsel_bbox = [min_x, min_y, max_x, max_y];
- this.redraw(); // background changed, redraw on screen
- };
-
- // redraw what user sees = static image + dynamic parts
- Schematic.prototype.redraw = function () {
- var c = this.canvas.getContext("2d");
-
- // put static image in the background
- c.drawImage(this.bg_image, 0, 0);
-
- // selected components
- var min_x = this.unsel_bbox[0]; // compute bounding box for diagram
- var max_x = this.unsel_bbox[2];
- var min_y = this.unsel_bbox[1];
- var max_y = this.unsel_bbox[3];
- var selections = false;
- for (var i = this.components.length - 1; i >= 0; --i) {
- var component = this.components[i];
- if (component.selected) {
- component.draw(c);
- selections = true;
- min_x = Math.min(component.bbox[0], min_x);
- max_x = Math.max(component.bbox[2], max_x);
- min_y = Math.min(component.bbox[1], min_y);
- max_y = Math.max(component.bbox[3], max_y);
- }
- }
- if (min_x == Infinity) this.bbox = [0, 0, 0, 0];
- else this.bbox = [min_x, min_y, max_x, max_y];
- this.enable_tool("cut", selections);
- this.enable_tool("copy", selections);
- this.enable_tool("paste", sch_clipboard.length > 0);
-
- // connection points: draw one at each location
- for (var location in this.connection_points) {
- var cplist = this.connection_points[location];
- cplist[0].draw(c, cplist.length);
- }
-
- // draw new wire
- if (this.wire) {
- var r = this.wire;
- c.strokeStyle = selected_style;
- this.draw_line(c, r[0], r[1], r[2], r[3], 1);
- }
-
- // draw selection rectangle
- if (this.select_rect) {
- var r = this.select_rect;
- c.lineWidth = 1;
- c.strokeStyle = selected_style;
- c.beginPath();
- c.moveTo(r[0], r[1]);
- c.lineTo(r[0], r[3]);
- c.lineTo(r[2], r[3]);
- c.lineTo(r[2], r[1]);
- c.lineTo(r[0], r[1]);
- c.stroke();
- }
-
- // display operating point results
- if (this.operating_point) {
- if (typeof this.operating_point == "string") this.message(this.operating_point);
- else {
- // make a copy of the operating_point info so we can mess with it
- var temp = [];
- for (var i in this.operating_point) temp[i] = this.operating_point[i];
-
- // run through connection points displaying (once) the voltage
- // for each electrical node
- for (var location in this.connection_points) this.connection_points[location][0].display_voltage(c, temp);
-
- // let components display branch current info if available
- for (var i = this.components.length - 1; i >= 0; --i) this.components[i].display_current(c, temp);
- }
- }
-
- // add scrolling/zooming control
- if (!this.diagram_only) {
- var r = this.sctl_r;
- var x = this.sctl_x;
- var y = this.sctl_y;
-
- // circle with border
- c.fillStyle = element_style;
- c.beginPath();
- c.arc(x, y, r, 0, 2 * Math.PI);
- c.fill();
-
- c.strokeStyle = grid_style;
- c.lineWidth = 0.5;
- c.beginPath();
- c.arc(x, y, r, 0, 2 * Math.PI);
- c.stroke();
-
- // direction markers for scroll
- c.lineWidth = 3;
- c.beginPath();
-
- c.moveTo(x + 4, y - r + 8); // north
- c.lineTo(x, y - r + 4);
- c.lineTo(x - 4, y - r + 8);
-
- c.moveTo(x + r - 8, y + 4); // east
- c.lineTo(x + r - 4, y);
- c.lineTo(x + r - 8, y - 4);
-
- c.moveTo(x + 4, y + r - 8); // south
- c.lineTo(x, y + r - 4);
- c.lineTo(x - 4, y + r - 8);
-
- c.moveTo(x - r + 8, y + 4); // west
- c.lineTo(x - r + 4, y);
- c.lineTo(x - r + 8, y - 4);
-
- c.stroke();
-
- // zoom control
- x = this.zctl_left;
- y = this.zctl_top;
- c.lineWidth = 0.5;
- c.fillStyle = element_style; // background
- c.fillRect(x, y, 16, 48);
- c.strokeStyle = grid_style; // border
- c.strokeRect(x, y, 16, 48);
- c.lineWidth = 1.0;
- c.beginPath();
- // zoom in label
- c.moveTo(x + 4, y + 8);
- c.lineTo(x + 12, y + 8);
- c.moveTo(x + 8, y + 4);
- c.lineTo(x + 8, y + 12);
- // zoom out label
- c.moveTo(x + 4, y + 24);
- c.lineTo(x + 12, y + 24);
- // surround label
- c.strokeRect(x + 4, y + 36, 8, 8);
- c.stroke();
- }
- };
-
- // draws a cross cursor
- Schematic.prototype.cross_cursor = function (c, x, y) {
- this.draw_line(c, x - this.grid, y, x + this.grid, y, 1);
- this.draw_line(c, x, y - this.grid, x, y + this.grid, 1);
- };
-
- Schematic.prototype.moveTo = function (c, x, y) {
- c.moveTo((x - this.origin_x) * this.scale, (y - this.origin_y) * this.scale);
- };
-
- Schematic.prototype.lineTo = function (c, x, y) {
- c.lineTo((x - this.origin_x) * this.scale, (y - this.origin_y) * this.scale);
- };
-
- Schematic.prototype.draw_line = function (c, x1, y1, x2, y2, width) {
- c.lineWidth = width * this.scale;
- c.beginPath();
- c.moveTo((x1 - this.origin_x) * this.scale, (y1 - this.origin_y) * this.scale);
- c.lineTo((x2 - this.origin_x) * this.scale, (y2 - this.origin_y) * this.scale);
- c.stroke();
- };
-
- Schematic.prototype.draw_arc = function (c, x, y, radius, start_radians, end_radians, anticlockwise, width, filled) {
- c.lineWidth = width * this.scale;
- c.beginPath();
- c.arc(
- (x - this.origin_x) * this.scale,
- (y - this.origin_y) * this.scale,
- radius * this.scale,
- start_radians,
- end_radians,
- anticlockwise,
- );
- if (filled) c.fill();
- else c.stroke();
- };
-
- Schematic.prototype.draw_text = function (c, text, x, y, size) {
- c.font = size * this.scale + "pt sans-serif";
- c.fillText(text, (x - this.origin_x) * this.scale, (y - this.origin_y) * this.scale);
- };
-
- // add method to canvas to compute relative coords for event
- try {
- if (HTMLCanvasElement)
- HTMLCanvasElement.prototype.relMouseCoords = function (event) {
- // run up the DOM tree to figure out coords for top,left of canvas
- var totalOffsetX = 0;
- var totalOffsetY = 0;
- var currentElement = this;
- do {
- totalOffsetX += currentElement.offsetLeft;
- totalOffsetY += currentElement.offsetTop;
- } while ((currentElement = currentElement.offsetParent));
-
- // now compute relative position of click within the canvas
- this.mouse_x = event.pageX - totalOffsetX;
- this.mouse_y = event.pageY - totalOffsetY;
- this.page_x = event.pageX;
- this.page_y = event.pageY;
- };
- } catch (err) {
- // ignore
- }
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Event handling
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- // process keystrokes, consuming those that are meaningful to us
- function schematic_key_down(event) {
- if (!event) event = window.event;
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
- var code = event.keyCode;
-
- // keep track of modifier key state
- if (code == 16) sch.shiftKey = true;
- else if (code == 17) sch.ctrlKey = true;
- else if (code == 18) sch.altKey = true;
- else if (code == 91) sch.cmdKey = true;
- // backspace or delete: delete selected components
- else if (code == 8 || code == 46) {
- // delete selected components
- for (var i = sch.components.length - 1; i >= 0; --i) {
- var component = sch.components[i];
- if (component.selected) component.remove();
- }
- sch.clean_up_wires();
- sch.redraw_background();
- event.preventDefault();
- return false;
- }
-
- // cmd/ctrl x: cut
- else if ((sch.ctrlKey || sch.cmdKey) && code == 88) {
- sch.cut();
- event.preventDefault();
- return false;
- }
-
- // cmd/ctrl c: copy
- else if ((sch.ctrlKey || sch.cmdKey) && code == 67) {
- sch.copy();
- event.preventDefault();
- return false;
- }
-
- // cmd/ctrl v: paste
- else if ((sch.ctrlKey || sch.cmdKey) && code == 86) {
- sch.paste();
- event.preventDefault();
- return false;
- }
-
- // 'r': rotate component
- else if (!sch.ctrlKey && !sch.altKey && !sch.cmdKey && code == 82) {
- // rotate
- for (var i = sch.components.length - 1; i >= 0; --i) {
- var component = sch.components[i];
- if (component.selected) {
- component.rotate(1);
- sch.check_wires(component);
- }
- }
- sch.clean_up_wires();
- sch.redraw_background();
- event.preventDefault();
- return false;
- } else return true;
-
- // consume keystroke
- sch.redraw();
- event.preventDefault();
- return false;
- }
-
- function schematic_key_up(event) {
- if (!event) event = window.event;
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
- var code = event.keyCode;
-
- if (code == 16) sch.shiftKey = false;
- else if (code == 17) sch.ctrlKey = false;
- else if (code == 18) sch.altKey = false;
- else if (code == 91) sch.cmdKey = false;
- }
-
- function schematic_mouse_enter(event) {
- if (!event) event = window.event;
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
-
- // see if user has selected a new part
- if (sch.new_part) {
- // grab incoming part, turn off selection of parts bin
- var part = sch.new_part;
- sch.new_part = undefined;
- part.select(false);
-
- // unselect everything else in the schematic, add part and select it
- sch.unselect_all(-1);
- sch.redraw_background(); // so we see any components that got unselected
-
- // make a clone of the component in the parts bin
- part = part.component.clone(sch.cursor_x, sch.cursor_y);
- part.add(sch); // add it to schematic
- part.set_select(true);
-
- // and start dragging it
- sch.drag_begin();
- }
-
- sch.drawCursor = true;
- sch.redraw();
- sch.canvas.focus(); // capture key strokes
- return false;
- }
-
- function schematic_mouse_leave(event) {
- if (!event) event = window.event;
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
- sch.drawCursor = false;
- sch.redraw();
- return false;
- }
-
- function schematic_mouse_down(event) {
- if (!event) event = window.event;
- else event.preventDefault();
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
-
- // determine where event happened in schematic coordinates
- sch.canvas.relMouseCoords(event);
-
- var mx = sch.canvas.mouse_x;
- var my = sch.canvas.mouse_y;
- var sx = mx - sch.sctl_x;
- var sy = my - sch.sctl_y;
- var zx = mx - sch.zctl_left;
- var zy = my - sch.zctl_top;
- if (sx * sx + sy * sy <= sch.sctl_r * sch.sctl_r) {
- // click in scrolling control
- // click on scrolling control, check which quadrant
- if (Math.abs(sy) > Math.abs(sx)) {
- // N or S
- var delta = this.height / 8;
- if (sy > 0) delta = -delta;
- var temp = sch.origin_y - delta;
- if (temp > origin_min * sch.grid && temp < origin_max * sch.grid) sch.origin_y = temp;
- } else {
- // E or W
- var delta = this.width / 8;
- if (sx < 0) delta = -delta;
- var temp = sch.origin_x + delta;
- if (temp > origin_min * sch.grid && temp < origin_max * sch.grid) sch.origin_x = temp;
- }
- } else if (zx >= 0 && zx < 16 && zy >= 0 && zy < 48) {
- // click in zoom control
- if (zy < 16) sch.zoomin();
- else if (zy < 32) sch.zoomout();
- else sch.zoomall();
- } else {
- var x = mx / sch.scale + sch.origin_x;
- var y = my / sch.scale + sch.origin_y;
- sch.cursor_x = Math.round(x / sch.grid) * sch.grid;
- sch.cursor_y = Math.round(y / sch.grid) * sch.grid;
-
- // is mouse over a connection point? If so, start dragging a wire
- var cplist = sch.connection_points[sch.cursor_x + "," + sch.cursor_y];
- if (cplist && !event.shiftKey) {
- sch.unselect_all(-1);
- sch.wire = [sch.cursor_x, sch.cursor_y, sch.cursor_x, sch.cursor_y];
- } else {
- // give all components a shot at processing the selection event
- var which = -1;
- for (var i = sch.components.length - 1; i >= 0; --i)
- if (sch.components[i].select(x, y, event.shiftKey)) {
- if (sch.components[i].selected) {
- sch.drag_begin();
- which = i; // keep track of component we found
- }
- break;
- }
- // did we just click on a previously selected component?
- var reselect = which != -1 && sch.components[which].was_previously_selected;
-
- if (!event.shiftKey) {
- // if shift key isn't pressed and we didn't click on component
- // that was already selected, unselect everyone except component
- // we just clicked on
- if (!reselect) sch.unselect_all(which);
-
- // if there's nothing to drag, set up a selection rectangle
- if (!sch.dragging)
- sch.select_rect = [sch.canvas.mouse_x, sch.canvas.mouse_y, sch.canvas.mouse_x, sch.canvas.mouse_y];
- }
- }
- }
-
- sch.redraw_background();
- return false;
- }
-
- function schematic_mouse_move(event) {
- if (!event) event = window.event;
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
-
- sch.canvas.relMouseCoords(event);
- var x = sch.canvas.mouse_x / sch.scale + sch.origin_x;
- var y = sch.canvas.mouse_y / sch.scale + sch.origin_y;
- sch.cursor_x = Math.round(x / sch.grid) * sch.grid;
- sch.cursor_y = Math.round(y / sch.grid) * sch.grid;
-
- if (sch.wire) {
- // update new wire end point
- sch.wire[2] = sch.cursor_x;
- sch.wire[3] = sch.cursor_y;
- } else if (sch.dragging) {
- // see how far we moved
- var dx = sch.cursor_x - sch.drag_x;
- var dy = sch.cursor_y - sch.drag_y;
- if (dx != 0 || dy != 0) {
- // update position for next time
- sch.drag_x = sch.cursor_x;
- sch.drag_y = sch.cursor_y;
-
- // give all components a shot at processing the event
- for (var i = sch.components.length - 1; i >= 0; --i) {
- var component = sch.components[i];
- if (component.selected) component.move(dx, dy);
- }
- }
- } else if (sch.select_rect) {
- // update moving corner of selection rectangle
- sch.select_rect[2] = sch.canvas.mouse_x;
- sch.select_rect[3] = sch.canvas.mouse_y;
- }
-
- // just redraw dynamic components
- sch.redraw();
-
- return false;
- }
-
- function schematic_mouse_up(event) {
- if (!event) event = window.event;
- else event.preventDefault();
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
-
- // drawing a new wire
- if (sch.wire) {
- var r = sch.wire;
- sch.wire = undefined;
-
- if (r[0] != r[2] || r[1] != r[3]) {
- // insert wire component
- sch.add_wire(r[0], r[1], r[2], r[3]);
- sch.clean_up_wires();
- sch.redraw_background();
- } else sch.redraw();
- }
-
- // dragging
- if (sch.dragging) sch.drag_end();
-
- // selection rectangle
- if (sch.select_rect) {
- var r = sch.select_rect;
-
- // if select_rect is a point, we've already dealt with selection
- // in mouse_down handler
- if (r[0] != r[2] || r[1] != r[3]) {
- // convert to schematic coordinates
- var s = [
- r[0] / sch.scale + sch.origin_x,
- r[1] / sch.scale + sch.origin_y,
- r[2] / sch.scale + sch.origin_x,
- r[3] / sch.scale + sch.origin_y,
- ];
- canonicalize(s);
-
- if (!event.shiftKey) sch.unselect_all();
-
- // select components that intersect selection rectangle
- for (var i = sch.components.length - 1; i >= 0; --i) sch.components[i].select_rect(s, event.shiftKey);
- }
-
- sch.select_rect = undefined;
- sch.redraw_background();
- }
- return false;
- }
-
- function schematic_mouse_wheel(event) {
- if (!event) event = window.event;
- else event.preventDefault();
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
-
- var delta = 0;
- if (event.wheelDelta) delta = event.wheelDelta;
- else if (event.detail) delta = -event.detail;
-
- if (delta) {
- var nscale = delta > 0 ? sch.scale * zoom_factor : sch.scale / zoom_factor;
-
- if (nscale > zoom_min && nscale < zoom_max) {
- // zoom around current mouse position
- sch.canvas.relMouseCoords(event);
- var s = 1.0 / sch.scale - 1.0 / nscale;
- sch.origin_x += sch.canvas.mouse_x * s;
- sch.origin_y += sch.canvas.mouse_y * s;
- sch.scale = nscale;
- sch.redraw_background();
- }
- }
- }
-
- function schematic_double_click(event) {
- if (!event) event = window.event;
- else event.preventDefault();
- var sch = window.event ? event.srcElement.schematic : event.target.schematic;
-
- // determine where event happened in schematic coordinates
- sch.canvas.relMouseCoords(event);
- var x = sch.canvas.mouse_x / sch.scale + sch.origin_x;
- var y = sch.canvas.mouse_y / sch.scale + sch.origin_y;
- sch.cursor_x = Math.round(x / sch.grid) * sch.grid;
- sch.cursor_y = Math.round(y / sch.grid) * sch.grid;
-
- // see if we double-clicked a component. If so, edit it's properties
- for (var i = sch.components.length - 1; i >= 0; --i) if (sch.components[i].edit_properties(x, y)) break;
-
- return false;
- }
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Status message and dialogs
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- Schematic.prototype.message = function (message) {
- this.status.nodeValue = message;
- };
-
- Schematic.prototype.append_message = function (message) {
- this.status.nodeValue += " / " + message;
- };
-
- // set up a dialog with specified title, content and two buttons at
- // the bottom: OK and Cancel. If Cancel is clicked, dialog goes away
- // and we're done. If OK is clicked, dialog goes away and the
- // callback function is called with the content as an argument (so
- // that the values of any fields can be captured).
- Schematic.prototype.dialog = function (title, content, callback) {
- // create the div for the top level of the dialog, add to DOM
- var dialog = document.createElement("div");
- dialog.sch = this;
- dialog.content = content;
- dialog.callback = callback;
-
- // look for property input fields in the content and give
- // them a keypress listener that interprets ENTER as
- // clicking OK.
- var plist = content.getElementsByClassName("property");
- for (var i = plist.length - 1; i >= 0; --i) {
- var field = plist[i];
- field.dialog = dialog; // help event handler find us...
- field.addEventListener("keypress", dialog_check_for_ENTER, false);
- }
-
- // div to hold the content
- var body = document.createElement("div");
- content.style.marginBotton = "5px";
- body.appendChild(content);
- body.style.padding = "5px";
- dialog.appendChild(body);
-
- var ok_button = document.createElement("span");
- ok_button.appendChild(document.createTextNode("OK"));
- ok_button.dialog = dialog; // for the handler to use
- ok_button.addEventListener("click", dialog_okay, false);
- ok_button.style.display = "inline";
- ok_button.style.border = "1px solid";
- ok_button.style.padding = "5px";
- ok_button.style.margin = "10px";
-
- var cancel_button = document.createElement("span");
- cancel_button.appendChild(document.createTextNode("Cancel"));
- cancel_button.dialog = dialog; // for the handler to use
- cancel_button.addEventListener("click", dialog_cancel, false);
- cancel_button.style.display = "inline";
- cancel_button.style.border = "1px solid";
- cancel_button.style.padding = "5px";
- cancel_button.style.margin = "10px";
-
- // div to hold the two buttons
- var buttons = document.createElement("div");
- buttons.style.textAlign = "center";
- buttons.appendChild(ok_button);
- buttons.appendChild(cancel_button);
- buttons.style.padding = "5px";
- buttons.style.margin = "10px";
- dialog.appendChild(buttons);
-
- // put into an overlay window
- this.window(title, dialog);
- };
-
- function dialog_cancel(event) {
- if (!event) event = window.event;
- var dialog = window.event ? event.srcElement.dialog : event.target.dialog;
-
- window_close(dialog.win);
- }
-
- function dialog_okay(event) {
- if (!event) event = window.event;
- var dialog = window.event ? event.srcElement.dialog : event.target.dialog;
-
- window_close(dialog.win);
-
- if (dialog.callback) dialog.callback(dialog.content);
- }
-
- // callback for keypress in input fields: if user typed ENTER, act
- // like they clicked OK button.
- function dialog_check_for_ENTER(event) {
- var key = window.event ? window.event.keyCode : event.keyCode;
- if (key == 13) dialog_okay(event);
- }
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Draggable, resizeable, closeable window
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- // build a 2-column HTML table from an associative array (keys as text in
- // column 1, values in column 2).
- function build_table(a) {
- var tbl = document.createElement("table");
-
- // build a row for each element in associative array
- for (var i in a) {
- var label = document.createTextNode(i + ": ");
- var col1 = document.createElement("td");
- col1.appendChild(label);
- var col2 = document.createElement("td");
- col2.appendChild(a[i]);
- var row = document.createElement("tr");
- row.appendChild(col1);
- row.appendChild(col2);
- row.style.verticalAlign = "center";
- tbl.appendChild(row);
- }
-
- return tbl;
- }
-
- function build_input(type, size, value) {
- var input = document.createElement("input");
- input.type = type;
- input.size = size;
- input.className = "property"; // make this easier to find later
- if (value == undefined) input.value = "";
- else input.value = value.toString();
- return input;
- }
-
- // build a select widget using the strings found in the options array
- function build_select(options, selected) {
- var select = document.createElement("select");
- for (var i = 0; i < options.length; i++) {
- var option = document.createElement("option");
- option.text = options[i];
- select.add(option);
- if (options[i] == selected) select.selectedIndex = i;
- }
- return select;
- }
-
- Schematic.prototype.window = function (title, content, offset) {
- // create the div for the top level of the window
- var win = document.createElement("div");
- win.sch = this;
- win.content = content;
- win.drag_x = undefined;
- win.draw_y = undefined;
-
- // div to hold the title
- var head = document.createElement("div");
- head.style.backgroundColor = "black";
- head.style.color = "white";
- head.style.textAlign = "center";
- head.style.padding = "5px";
- head.appendChild(document.createTextNode(title));
- head.win = win;
- win.head = head;
-
- var close_button = new Image();
- close_button.src = close_icon;
- close_button.style.cssFloat = "right";
- close_button.addEventListener("click", window_close_button, false);
- close_button.win = win;
- head.appendChild(close_button);
-
- win.appendChild(head);
-
- // capture mouse events in title bar
- head.addEventListener("mousedown", window_mouse_down, false);
-
- // div to hold the content
- //var body = document.createElement('div');
- //body.appendChild(content);
- win.appendChild(content);
- content.win = win; // so content can contact us
-
- // compute location relative to canvas
- if (offset == undefined) offset = 0;
- win.left = this.canvas.mouse_x + offset;
- win.top = this.canvas.mouse_y + offset;
-
- // add to DOM
- win.style.background = "white";
- win.style.position = "absolute";
- win.style.left = win.left + "px";
- win.style.top = win.top + "px";
- win.style.border = "2px solid";
-
- this.canvas.parentNode.insertBefore(win, this.canvas);
- bring_to_front(win, true);
- };
-
- // adjust zIndex of pop-up window so that it is in front
- function bring_to_front(win, insert) {
- var wlist = win.sch.window_list;
- var i = wlist.indexOf(win);
-
- // remove from current position (if any) in window list
- if (i != -1) wlist.splice(i, 1);
-
- // if requested, add to end of window list
- if (insert) wlist.push(win);
-
- // adjust all zIndex values
- for (i = 0; i < wlist.length; i += 1) wlist[i].style.zIndex = 1000 + i;
- }
-
- // close the window
- function window_close(win) {
- // remove the window from the top-level div of the schematic
- win.parentNode.removeChild(win);
-
- // remove from list of pop-up windows
- bring_to_front(win, false);
- }
-
- function window_close_button(event) {
- if (!event) event = window.event;
- var src = window.event ? event.srcElement : event.target;
- window_close(src.win);
- }
-
- // capture mouse events in title bar of window
- function window_mouse_down(event) {
- if (!event) event = window.event;
- var src = window.event ? event.srcElement : event.target;
- var win = src.win;
-
- bring_to_front(win, true);
-
- // add handlers to document so we capture them no matter what
- document.addEventListener("mousemove", window_mouse_move, false);
- document.addEventListener("mouseup", window_mouse_up, false);
- document.tracking_window = win;
-
- // remember where mouse is so we can compute dx,dy during drag
- win.drag_x = event.pageX;
- win.drag_y = event.pageY;
-
- return false;
- }
-
- function window_mouse_up(event) {
- var win = document.tracking_window;
-
- // show's over folks...
- document.removeEventListener("mousemove", window_mouse_move, false);
- document.removeEventListener("mouseup", window_mouse_up, false);
- document.tracking_window = undefined;
- win.drag_x = undefined;
- win.drag_y = undefined;
- return true; // consume event
- }
-
- function window_mouse_move(event) {
- var win = document.tracking_window;
-
- if (win.drag_x) {
- var dx = event.pageX - win.drag_x;
- var dy = event.pageY - win.drag_y;
-
- // move the window
- win.left += dx;
- win.top += dy;
- win.style.left = win.left + "px";
- win.style.top = win.top + "px";
-
- // update reference point
- win.drag_x += dx;
- win.drag_y += dy;
-
- return true; // consume event
- }
- }
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Toolbar
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- Schematic.prototype.add_tool = function (icon, tip, callback) {
- var tool, child, label, hidden;
-
- tool = document.createElement("button");
- child = document.createElement("img");
- label = document.createElement("span");
- hidden = document.createElement("span");
-
- tool.style.backgroundImage = "none";
- tool.setAttribute("title", tip);
- label.innerHTML = tip;
- label.classList.add("sr");
- hidden.setAttribute("aria-hidden", "true");
-
- if (icon.search("data:image") != -1) {
- child.setAttribute("src", icon);
- child.setAttribute("alt", "");
- tool.appendChild(child);
- } else {
- tool.style.font = "small-caps small sans-serif";
- hidden.innerHTML = icon;
- tool.appendChild(hidden);
- tool.appendChild(label);
- }
-
- // decorate tool
- tool.style.height = "32px";
- tool.style.width = "auto";
- tool.style.verticalAlign = "top";
-
- // set up event processing
- tool.addEventListener("mouseover", tool_enter, false);
- tool.addEventListener("mouseout", tool_leave, false);
- tool.addEventListener("click", tool_click, false);
-
- // add to toolbar
- tool.sch = this;
- tool.tip = tip;
- tool.callback = callback;
- this.toolbar.push(tool);
-
- tool.enabled = false;
-
- return tool;
- };
-
- Schematic.prototype.enable_tool = function (tname, which) {
- var tool = this.tools[tname];
-
- if (tool != undefined) {
- tool.removeAttribute("disabled");
- tool.enabled = which;
-
- // if disabling tool, remove border and tip
- if (!which) {
- tool.sch.message("");
- tool.setAttribute("disabled", "true");
- }
- }
- };
-
- // highlight tool button by turning on border, changing background
- function tool_enter(event) {
- if (!event) event = window.event;
- var tool = event.target;
- if (event.target.tagName.toLowerCase() == "img" || event.target.tagName.toLowerCase() == "span") {
- tool = event.target.parentNode;
- }
- if (tool.enabled) {
- tool.sch.message(tool.tip);
- }
- event.stopPropagation();
- }
-
- // unhighlight tool button by turning off border, reverting to normal background
- function tool_leave(event) {
- if (!event) event = window.event;
- var tool = event.target;
- if (event.target.tagName.toLowerCase() == "img" || event.target.tagName.toLowerCase() == "span") {
- tool = event.target.parentNode;
- }
- if (tool.enabled) {
- tool.sch.message("");
- }
- event.stopPropagation();
- }
-
- // handle click on a tool
- function tool_click(event) {
- if (!event) event = window.event;
- var tool = event.target;
- if (event.target.tagName.toLowerCase() == "img" || event.target.tagName.toLowerCase() == "span") {
- tool = event.target.parentNode;
- }
- if (tool.enabled) {
- tool.sch.canvas.relMouseCoords(event); // so we can position pop-up window correctly
- tool.callback.call(tool.sch);
- }
- event.stopPropagation();
- }
-
- var help_icon =
- "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAABgFBMVEUARMwAZsz///8AM5kGqP+s1/8AeuARp/8AZ803qPsAXNYAdNwAZcxZuv9auf99xv8AdNoEd9uTzP8AYsgAivQTl/cAj/V9xf8Ad90AeN5PtP8AUMoAj/oRiOgprf84qfwAb9UAifAAdtwAf+UAgOYActgAk/oAie8cqP8AbtQAXtkXof8AatBNuP8AbdMAgukXcOEAXdcAlP0AhuwJmv0prv8YceGCyP8AbtUAZd8elvMAZcsAW9Ucpv8AjfM3sP8AiO4AWdNOuP8AddsPgeIAhOoAbdT///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABH5RCxAAAASHRSTlP//////////////////////////////////////////////////////////////////////////////////////////////wCc7PJgAAAAAWJLR0R/SL9x5QAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFnAAAAEAAAABAAXMatwwAAAK5JREFUGNM1zwcOwjAMBVAHQ9PFbIG27L333pve/0bEBr5kyf9JkWIIKYLDK3CNcZgUiE0QFIuuu89kBIHIDy5TUOmXSknBsFxDRAXMJ4FIZOeqA41lxQVB+w/1L9RyO+B+fLwJ7q/OOUfd9FvDkQJDmyyuoLqWGtsVBq3RnAHcUlXbNgSEWPY8n570dH2F6h94Sqe3BAdd7xKEKKVTACg4UuL3OMQoB/F3LRGF1w/Arhm2Q9w2ZQAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOC0xMC0yM1QxMTo1ODozNiswODowMKkTWd4AAAAldEVYdG1vZGlmeS1kYXRlADIwMDgtMTAtMjNUMTE6NTk6NTArMDg6MDC833hpAAAAAElFTkSuQmCC";
-
- var cut_icon =
- "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH1QocFh0xaEFkXgAAArRJREFUOMuFk11Ik1EYx59z3nevr9vUfaXbbPgVaHjRVRB0YZRJV0XeZCIRaGmWWKhpgZAElaV9gYgQlBjoEPRKkCS6DAK1MG0zNvJj7zZ1m+51X+92zttNzmFa5+78/w8//s/znIMg5TzrfXIOAN7zPO9tunm7dI/Xz7LspTvNrbpUHadeGIYZu9XYrI1Go8t9/a87Uz0Fq7hw5nS55sWrnk8HAggh/E+HHdfV1lcQQo7t6E97HpeZc82m7ZCIKKUnDgRgjENLS7+AT0tDsVisdCcFy7JThYWF4HF7KKXU8a8EFTabDVZdK6iutr44kUic6nnePVBSUqJAgMHhdAAAWA8E3G299xljvLy4aAc+jUeSJB3X6/TXZAqwvrFGAWCiraXj4YEAAABKaeXCjwV5bc0DjTeaVPFEHIliEObm5iQA6Npb/xegraVjGmM8ZF+00WBwC2s0GhDcgizL8ru2lo7p/wL+pJianZnGTqcD0jkeMt8ORhBCb/arRXuFMaOxl1B6Pb65qSblZTIz+REVGHNAIHQLITRQ6fG07wsYM5k6437/g6MmEyQoRd6tTdkX3h5mZVRVkJ3D8BxHJVkG5/o6KLKyrla63UPJFsbN5hrJ5+sqNhrpwsrKVDASlgJBEdfEaU2UIzqWwTQQEhOO1dUPR/R6EvP5BsfN5t2XOmowCPNFRWSEYe4DAMxYLCGrUpnY8UcYhnzJNQcBAIYxbv+Wn09GDQZhd4ixmF6SJFJFyKMJleqlgmV5hLE9OWmOm1Hz6arJjIy+y5R2gyxTIMSwC+A4Qa1UMl/z8mImna5pXhC8iszMK8mPpNU2fHe5Ng4fOtQwa7HECKUYMA4AADAAANVarc/l95/0SxIbAJA5tfrsRUFI7twqiu7q7GyPNxDI8YfDGl8k4lOoVOetouj+DaDzOgfcNME8AAAAAElFTkSuQmCC";
-
- var copy_icon =
- "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsSAAALEgHS3X78AAAAd0lEQVQ4y9WTsQ7AIAhE7wj//69dHKWLJqSlFOtUFpXA8SAIbBrHaR9yAAA6L2bvGiRvPtltQa+OqMrFPCo1jFhoRytBmXgqUCH5GUEkWCbova8TeBORfBNJVpYIrbVJdwDjY5hjJfk4vFnAzMDxiEqmo/fJAHACspMyA7UYnWgAAAAASUVORK5CYII=";
-
- var paste_icon =
- "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsSAAALEgHS3X78AAABZElEQVQ4y6WSMUsDMRiGn6RteoJSENS5oCdFR3+D0MHBciA4uujiVrq0o1NBcBEEFycXRzcnf4GDINTiL7BTr9LeJdfGoaX0ei21+MFHAsn7fG9eAjOqXCwoz/NKgAWs53mlcrGgZt0VE3s7fdhsfgHguttztTHA5+0ZjUaDzdM7HEeRy60C0G7/EASa78cLXNelcPkw1qYnkVprfN/n+6aEUgqlFFJKjDForclms2itYzZigH6/Tz6fp9PpAFC8fp3h/J2rw42P2ksLADkNMMbgOA6O4wzfZW2sAWovrb3janUn4cAYgzGGRWWtRQjRPKpUdmOAKIrGgCiK5gKEGGb/XK9/JhwEQUC32yUMw7nTJ0ExQK/Xw/d9BoPBeMqiigHCMEQIQSqV+pM4AbCAXEKcAGAtKSn/AYCE/UVZpIEVYA1ASkkmkxl/mqfzg5ExG1tP7t8AtoAOwDqwP4pgmd4H1n8B+QWeF/d+HLAAAAAASUVORK5CYII=";
-
- var close_icon =
- "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAACOUlEQVR42m2TzWtTQRTF30ysxE9E0VZKaapBa1OJxtRAW7XVGOrCKijFIEqXbgQFwf/BTReia7GUuBEUF5Y2YiMKKn6iKEqRom1DtAsjStGaGX9v3iQ+Y4Z35t6ZOfe8uXdmhFPVDqRSktYvpBzAxphaBQpKqSdalTLYO7fHxnWZL/zBfclkWAbksBBip7cmHEGvDd3raFlVUoOj2Wz+H4H9vT0RGQhMMLHGkxaienduuJV6p0ql5PjdiRlD2rurO0jwM9zWWnG1dPhyWql9ht3T1XmKwEtAaLNVMUT3AFyBsAz7g9lBbBc4+zcb54joTnQIKeRDZjrcvyNQxG9A5Bd2NwIZ+Gn8e2AxmHNFbTbXRWc8FoRcJLjObtDtbjB3DLtALZbws3l8d/0aOOzLZlYktkfX4eS9epuiehlqZ+TRi5cny8zEtuhVVo/7eabW8a2RFdivwlbPbu079uDT129yZYEd7W17oNzCXe4rdFHE2lrd0SRosbX5TXAK5EAd5NPYi9gF0AtGwSIrcN9IRTeFLxB8zp7RPAExMAUxAw7h3wRpdh+SQjzHBm0KZ4xA+8aWRgivzLU16TvuLZsB8UqyjvMYNDOu98rgfEQ8UklmS6hpQCs9ghuwdShfSKF9Ezb/n5x939upT7mKwOamRogqjchlhit9R+XbhGlfeGgn3k/Pjv33mNwWXl8f4sWdJ+Yow9W+JTetYSkDQ5P5wuear7HcNjSs5Upqd60ZLAXfwPSHwpyu5v4BhpTicEl0i9QAAAAASUVORK5CYII=";
-
- var grid_icon =
- "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsSAAALEgHS3X78AAAAMklEQVQ4y2NkYGD4z0ABYGFgYGD4/x/VDEZGRqLFmCixnYGBYRAYwMgwGoijgTgsAhEAq84fH/l+ELYAAAAASUVORK5CYII=";
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Graphing
- //
- ///////////////////////////////////////////////////////////////////////////////
-
- // add dashed lines!
- // from http://davidowens.wordpress.com/2010/09/07/html-5-canvas-and-dashed-lines/
- try {
- if (CanvasRenderingContext2D)
- CanvasRenderingContext2D.prototype.dashedLineTo = function (fromX, fromY, toX, toY, pattern) {
- // Our growth rate for our line can be one of the following:
- // (+,+), (+,-), (-,+), (-,-)
- // Because of this, our algorithm needs to understand if the x-coord and
- // y-coord should be getting smaller or larger and properly cap the values
- // based on (x,y).
- var lt = function (a, b) {
- return a <= b;
- };
- var gt = function (a, b) {
- return a >= b;
- };
- var capmin = function (a, b) {
- return Math.min(a, b);
- };
- var capmax = function (a, b) {
- return Math.max(a, b);
- };
- var checkX = { thereYet: gt, cap: capmin };
- var checkY = { thereYet: gt, cap: capmin };
-
- if (fromY - toY > 0) {
- checkY.thereYet = lt;
- checkY.cap = capmax;
- }
- if (fromX - toX > 0) {
- checkX.thereYet = lt;
- checkX.cap = capmax;
- }
-
- this.moveTo(fromX, fromY);
- var offsetX = fromX;
- var offsetY = fromY;
- var idx = 0,
- dash = true;
- while (!(checkX.thereYet(offsetX, toX) && checkY.thereYet(offsetY, toY))) {
- var ang = Math.atan2(toY - fromY, toX - fromX);
- var len = pattern[idx];
-
- offsetX = checkX.cap(toX, offsetX + Math.cos(ang) * len);
- offsetY = checkY.cap(toY, offsetY + Math.sin(ang) * len);
-
- if (dash) this.lineTo(offsetX, offsetY);
- else this.moveTo(offsetX, offsetY);
-
- idx = (idx + 1) % pattern.length;
- dash = !dash;
- }
- };
- } catch (err) {
- //noop
- }
- // given a range of values, return a new range [vmin',vmax'] where the limits
- // have been chosen "nicely". Taken from matplotlib.ticker.LinearLocator
- function view_limits(vmin, vmax) {
- // deal with degenerate case...
- if (vmin == vmax) {
- if (vmin == 0) {
- vmin = -0.5;
- vmax = 0.5;
- } else {
- vmin = vmin > 0 ? 0.9 * vmin : 1.1 * vmin;
- vmax = vmax > 0 ? 1.1 * vmax : 0.9 * vmax;
- }
- }
-
- var log_range = Math.log(vmax - vmin) / Math.LN10;
- var exponent = Math.floor(log_range);
- //if (log_range - exponent < 0.5) exponent -= 1;
- var scale = Math.pow(10, -exponent);
- vmin = Math.floor(scale * vmin) / scale;
- vmax = Math.ceil(scale * vmax) / scale;
-
- return [vmin, vmax, 1.0 / scale];
- }
-
- function engineering_notation(n, nplaces, trim) {
- if (n == 0) return "0";
- if (n == undefined) return "undefined";
- if (trim == undefined) trim = true;
-
- var sign = n < 0 ? -1 : 1;
- var log10 = Math.log(sign * n) / Math.LN10;
- var exp = Math.floor(log10 / 3); // powers of 1000
- var mantissa = sign * Math.pow(10, log10 - 3 * exp);
-
- // keep specified number of places following decimal point
- var mstring = (mantissa + sign * 0.5 * Math.pow(10, -nplaces)).toString();
- var mlen = mstring.length;
- var endindex = mstring.indexOf(".");
- if (endindex != -1) {
- if (nplaces > 0) {
- endindex += nplaces + 1;
- if (endindex > mlen) endindex = mlen;
- if (trim) {
- while (mstring.charAt(endindex - 1) == "0") endindex -= 1;
- if (mstring.charAt(endindex - 1) == ".") endindex -= 1;
- }
- }
- if (endindex < mlen) mstring = mstring.substring(0, endindex);
- }
-
- switch (exp) {
- case -5:
- return mstring + "f";
- case -4:
- return mstring + "p";
- case -3:
- return mstring + "n";
- case -2:
- return mstring + "u";
- case -1:
- return mstring + "m";
- case 0:
- return mstring;
- case 1:
- return mstring + "K";
- case 2:
- return mstring + "M";
- case 3:
- return mstring + "G";
- }
-
- // don't have a good suffix, so just print the number
- return n.toString();
- }
-
- var grid_pattern = [1, 2];
- var cursor_pattern = [5, 5];
-
- // x_values is an array of x coordinates for each of the plots
- // y_values is an array of [color, value_array], one entry for each plot on left vertical axis
- // z_values is an array of [color, value_array], one entry for each plot on right vertical axis
- Schematic.prototype.graph = function (x_values, x_legend, y_values, y_legend, z_values, z_legend) {
- var pwidth = 400; // dimensions of actual plot
- var pheight = 300; // dimensions of actual plot
- var left_margin = y_values != undefined && y_values.length > 0 ? 55 : 25;
- var top_margin = 25;
- var right_margin = z_values != undefined && z_values.length > 0 ? 55 : 25;
- var bottom_margin = 45;
- var tick_length = 5;
-
- var w = pwidth + left_margin + right_margin;
- var h = pheight + top_margin + bottom_margin;
-
- var canvas = document.createElement("canvas");
- canvas.width = w;
- canvas.height = h;
-
- // the graph itself will be drawn here and this image will be copied
- // onto canvas, where it can be overlayed with mouse cursors, etc.
- var bg_image = document.createElement("canvas");
- bg_image.width = w;
- bg_image.height = h;
- canvas.bg_image = bg_image; // so we can find it during event handling
-
- // start by painting an opaque background
- var c = bg_image.getContext("2d");
- c.fillStyle = background_style;
- c.fillRect(0, 0, w, h);
- c.fillStyle = element_style;
- c.fillRect(left_margin, top_margin, pwidth, pheight);
-
- // figure out scaling for plots
- var x_min = array_min(x_values);
- var x_max = array_max(x_values);
- var x_limits = view_limits(x_min, x_max);
- x_min = x_limits[0];
- x_max = x_limits[1];
- var x_scale = pwidth / (x_max - x_min);
-
- function plot_x(x) {
- return (x - x_min) * x_scale + left_margin;
- }
-
- // draw x grid
- c.strokeStyle = grid_style;
- c.lineWidth = 1;
- c.fillStyle = normal_style;
- c.font = "10pt sans-serif";
- c.textAlign = "center";
- c.textBaseline = "top";
- var end = top_margin + pheight;
- for (var x = x_min; x <= x_max; x += x_limits[2]) {
- var temp = plot_x(x) + 0.5; // keep lines crisp!
-
- // grid line
- c.beginPath();
- if (x == x_min) {
- c.moveTo(temp, top_margin);
- c.lineTo(temp, end);
- } else c.dashedLineTo(temp, top_margin, temp, end, grid_pattern);
- c.stroke();
-
- // tick mark
- c.beginPath();
- c.moveTo(temp, end);
- c.lineTo(temp, end + tick_length);
- c.stroke();
- c.fillText(engineering_notation(x, 2), temp, end + tick_length);
- }
-
- if (y_values != undefined && y_values.length > 0) {
- var y_min = Infinity;
- var y_max = -Infinity;
- var plot;
- for (plot = y_values.length - 1; plot >= 0; --plot) {
- var values = y_values[plot][2];
- if (values == undefined) continue; // no data points
- var offset = y_values[plot][1];
- var temp = array_min(values) + offset;
- if (temp < y_min) y_min = temp;
- temp = array_max(values) + offset;
- if (temp > y_max) y_max = temp;
- }
- var y_limits = view_limits(y_min, y_max);
- y_min = y_limits[0];
- y_max = y_limits[1];
- var y_scale = pheight / (y_max - y_min);
-
- function plot_y(y) {
- return (y_max - y) * y_scale + top_margin;
- }
-
- // draw y grid
- c.textAlign = "right";
- c.textBaseline = "middle";
- for (var y = y_min; y <= y_max; y += y_limits[2]) {
- if (Math.abs(y / y_max) < 0.001) y = 0.0; // Just 3 digits
- var temp = plot_y(y) + 0.5; // keep lines crisp!
-
- // grid line
- c.beginPath();
- if (y == y_min) {
- c.moveTo(left_margin, temp);
- c.lineTo(left_margin + pwidth, temp);
- } else c.dashedLineTo(left_margin, temp, left_margin + pwidth, temp, grid_pattern);
- c.stroke();
-
- // tick mark
- c.beginPath();
- c.moveTo(left_margin - tick_length, temp);
- c.lineTo(left_margin, temp);
- c.stroke();
- c.fillText(engineering_notation(y, 2), left_margin - tick_length - 2, temp);
- }
-
- // now draw each plot
- var x, y;
- var nx, ny;
- c.lineWidth = 3;
- c.lineCap = "round";
- for (plot = y_values.length - 1; plot >= 0; --plot) {
- var color = probe_colors_rgb[y_values[plot][0]];
- if (color == undefined) continue; // no plot color (== x-axis)
- c.strokeStyle = color;
- var values = y_values[plot][2];
- if (values == undefined) continue; // no data points
- var offset = y_values[plot][1];
-
- x = plot_x(x_values[0]);
- y = plot_y(values[0] + offset);
- c.beginPath();
- c.moveTo(x, y);
- for (var i = 1; i < x_values.length; i++) {
- nx = plot_x(x_values[i]);
- ny = plot_y(values[i] + offset);
- c.lineTo(nx, ny);
- x = nx;
- y = ny;
- if (i % 100 == 99) {
- // too many lineTo's cause canvas to break
- c.stroke();
- c.beginPath();
- c.moveTo(x, y);
- }
- }
- c.stroke();
- }
- }
-
- if (z_values != undefined && z_values.length > 0) {
- var z_min = Infinity;
- var z_max = -Infinity;
- for (plot = z_values.length - 1; plot >= 0; --plot) {
- var values = z_values[plot][2];
- if (values == undefined) continue; // no data points
- var offset = z_values[plot][1];
- var temp = array_min(values) + offset;
- if (temp < z_min) z_min = temp;
- temp = array_max(values) + offset;
- if (temp > z_max) z_max = temp;
- }
- var z_limits = view_limits(z_min, z_max);
- z_min = z_limits[0];
- z_max = z_limits[1];
- var z_scale = pheight / (z_max - z_min);
-
- function plot_z(z) {
- return (z_max - z) * z_scale + top_margin;
- }
-
- // draw z ticks
- c.textAlign = "left";
- c.textBaseline = "middle";
- c.lineWidth = 1;
- c.strokeStyle = normal_style;
- var tick_length_half = Math.floor(tick_length / 2);
- var tick_delta = tick_length - tick_length_half;
- for (var z = z_min; z <= z_max; z += z_limits[2]) {
- if (Math.abs(z / z_max) < 0.001) z = 0.0; // Just 3 digits
- var temp = plot_z(z) + 0.5; // keep lines crisp!
-
- // tick mark
- c.beginPath();
- c.moveTo(left_margin + pwidth - tick_length_half, temp);
- c.lineTo(left_margin + pwidth + tick_delta, temp);
- c.stroke();
- c.fillText(engineering_notation(z, 2), left_margin + pwidth + tick_length + 2, temp);
- }
-
- var z;
- var nz;
- c.lineWidth = 3;
- for (plot = z_values.length - 1; plot >= 0; --plot) {
- var color = probe_colors_rgb[z_values[plot][0]];
- if (color == undefined) continue; // no plot color (== x-axis)
- c.strokeStyle = color;
- var values = z_values[plot][2];
- if (values == undefined) continue; // no data points
- var offset = z_values[plot][1];
-
- x = plot_x(x_values[0]);
- z = plot_z(values[0] + offset);
- c.beginPath();
- c.moveTo(x, z);
- for (var i = 1; i < x_values.length; i++) {
- nx = plot_x(x_values[i]);
- nz = plot_z(values[i] + offset);
- c.lineTo(nx, nz);
- x = nx;
- z = nz;
- if (i % 100 == 99) {
- // too many lineTo's cause canvas to break
- c.stroke();
- c.beginPath();
- c.moveTo(x, z);
- }
- }
- c.stroke();
- }
- }
-
- // draw legends
- c.font = "12pt sans-serif";
- c.textAlign = "center";
- c.textBaseline = "bottom";
- c.fillText(x_legend, left_margin + pwidth / 2, h - 5);
-
- if (y_values != undefined && y_values.length > 0) {
- c.textBaseline = "top";
- c.save();
- c.translate(5, top_margin + pheight / 2);
- c.rotate(-Math.PI / 2);
- c.fillText(y_legend, 0, 0);
- c.restore();
- }
-
- if (z_values != undefined && z_values.length > 0) {
- c.textBaseline = "bottom";
- c.save();
- c.translate(w - 5, top_margin + pheight / 2);
- c.rotate(-Math.PI / 2);
- c.fillText(z_legend, 0, 0);
- c.restore();
- }
-
- // save info need for interactions with the graph
- canvas.x_values = x_values;
- canvas.y_values = y_values;
- canvas.z_values = z_values;
- canvas.x_legend = x_legend;
- canvas.y_legend = y_legend;
- canvas.z_legend = y_legend;
- canvas.x_min = x_min;
- canvas.x_scale = x_scale;
- canvas.y_min = y_min;
- canvas.y_scale = y_scale;
- canvas.z_min = z_min;
- canvas.z_scale = z_scale;
- canvas.left_margin = left_margin;
- canvas.top_margin = top_margin;
- canvas.pwidth = pwidth;
- canvas.pheight = pheight;
- canvas.tick_length = tick_length;
-
- canvas.cursor1_x = undefined;
- canvas.cursor2_x = undefined;
- canvas.sch = this;
-
- // do something useful when user mouses over graph
- canvas.addEventListener("mousemove", graph_mouse_move, false);
-
- // return our masterpiece
- redraw_plot(canvas);
- return canvas;
- };
-
- function array_max(a) {
- var max = -Infinity;
- for (var i = a.length - 1; i >= 0; --i) if (a[i] > max) max = a[i];
- return max;
- }
-
- function array_min(a) {
- var min = Infinity;
- for (var i = a.length - 1; i >= 0; --i) if (a[i] < min) min = a[i];
- return min;
- }
-
- function plot_cursor(c, graph, cursor_x, left_margin) {
- // draw dashed vertical marker that follows mouse
- var x = graph.left_margin + cursor_x;
- var end_y = graph.top_margin + graph.pheight + graph.tick_length;
- c.strokeStyle = grid_style;
- c.lineWidth = 1;
- c.beginPath();
- c.dashedLineTo(x, graph.top_margin, x, end_y, cursor_pattern);
- c.stroke();
-
- // add x label at bottom of marker
- var graph_x = cursor_x / graph.x_scale + graph.x_min;
- c.font = "10pt sans-serif";
- c.textAlign = "center";
- c.textBaseline = "top";
- c.fillStyle = background_style;
- c.fillText("\u2588\u2588\u2588\u2588\u2588", x, end_y);
- c.fillStyle = normal_style;
- c.fillText(engineering_notation(graph_x, 3, false), x, end_y);
-
- // compute which points marker is between
- var x_values = graph.x_values;
- var len = x_values.length;
- var index = 0;
- while (index < len && graph_x >= x_values[index]) index += 1;
- var x1 = index == 0 ? x_values[0] : x_values[index - 1];
- var x2 = x_values[index];
-
- if (x2 != undefined) {
- // for each plot, interpolate and output value at intersection with marker
- c.textAlign = "left";
- var tx = graph.left_margin + left_margin;
- var ty = graph.top_margin;
- if (graph.y_values != undefined) {
- for (var plot = 0; plot < graph.y_values.length; plot++) {
- var values = graph.y_values[plot][2];
- var color = probe_colors_rgb[graph.y_values[plot][0]];
- if (values == undefined || color == undefined) continue; // no data points or x-axis
-
- // interpolate signal value at graph_x using values[index-1] and values[index]
- var y1 = index == 0 ? values[0] : values[index - 1];
- var y2 = values[index];
- var y = y1;
- if (graph_x != x1) y += ((graph_x - x1) * (y2 - y1)) / (x2 - x1);
-
- // annotate plot with value of signal at marker
- c.fillStyle = element_style;
- c.fillText("\u2588\u2588\u2588\u2588\u2588", tx - 3, ty);
- c.fillStyle = color;
- c.fillText(engineering_notation(y, 3, false), tx, ty);
- ty += 14;
- }
- }
-
- c.textAlign = "right";
- if (graph.z_values != undefined) {
- var tx = graph.left_margin + graph.pwidth - left_margin;
- var ty = graph.top_margin;
- for (var plot = 0; plot < graph.z_values.length; plot++) {
- var values = graph.z_values[plot][2];
- var color = probe_colors_rgb[graph.z_values[plot][0]];
- if (values == undefined || color == undefined) continue; // no data points or x-axis
-
- // interpolate signal value at graph_x using values[index-1] and values[index]
- var z1 = index == 0 ? values[0] : values[index - 1];
- var z2 = values[index];
- var z = z1;
- if (graph_x != x1) z += ((graph_x - x1) * (z2 - z1)) / (x2 - x1);
-
- // annotate plot with value of signal at marker
- c.fillStyle = element_style;
- c.fillText("\u2588\u2588\u2588\u2588\u2588", tx + 3, ty);
- c.fillStyle = color;
- c.fillText(engineering_notation(z, 3, false), tx, ty);
- ty += 14;
- }
- }
- }
- }
-
- function redraw_plot(graph) {
- var c = graph.getContext("2d");
- c.drawImage(graph.bg_image, 0, 0);
-
- if (graph.cursor1_x != undefined) plot_cursor(c, graph, graph.cursor1_x, 4);
- if (graph.cursor2_x != undefined) plot_cursor(c, graph, graph.cursor2_x, 30);
-
- /*
- if (graph.cursor1_x != undefined) {
- // draw dashed vertical marker that follows mouse
- var x = graph.left_margin + graph.cursor1_x;
- var end_y = graph.top_margin + graph.pheight + graph.tick_length;
- c.strokeStyle = grid_style;
- c.lineWidth = 1;
- c.beginPath();
- c.dashedLineTo(x,graph.top_margin,x,end_y,cursor_pattern);
- c.stroke();
-
- // add x label at bottom of marker
- var graph_x = graph.cursor1_x/graph.x_scale + graph.x_min;
- c.font = '10pt sans-serif';
- c.textAlign = 'center';
- c.textBaseline = 'top';
- c.fillStyle = background_style;
- c.fillText('\u2588\u2588\u2588\u2588\u2588',x,end_y);
- c.fillStyle = normal_style;
- c.fillText(engineering_notation(graph_x,3,false),x,end_y);
-
- // compute which points marker is between
- var x_values = graph.x_values;
- var len = x_values.length;
- var index = 0;
- while (index < len && graph_x >= x_values[index]) index += 1;
- var x1 = (index == 0) ? x_values[0] : x_values[index-1];
- var x2 = x_values[index];
-
- if (x2 != undefined) {
- // for each plot, interpolate and output value at intersection with marker
- c.textAlign = 'left';
- var tx = graph.left_margin + 4;
- var ty = graph.top_margin;
- for (var plot = 0; plot < graph.y_values.length; plot++) {
- var values = graph.y_values[plot][1];
-
- // interpolate signal value at graph_x using values[index-1] and values[index]
- var y1 = (index == 0) ? values[0] : values[index-1];
- var y2 = values[index];
- var y = y1;
- if (graph_x != x1) y += (graph_x - x1)*(y2 - y1)/(x2 - x1);
-
- // annotate plot with value of signal at marker
- c.fillStyle = element_style;
- c.fillText('\u2588\u2588\u2588\u2588\u2588',tx-3,ty);
- c.fillStyle = probe_colors_rgb[graph.y_values[plot][0]];
- c.fillText(engineering_notation(y,3,false),tx,ty);
- ty += 14;
- }
- }
- }
- */
- }
-
- function graph_mouse_move(event) {
- if (!event) event = window.event;
- var g = window.event ? event.srcElement : event.target;
-
- g.relMouseCoords(event);
- // not sure yet where the 3,-3 offset correction comes from (borders? padding?)
- var gx = g.mouse_x - g.left_margin - 3;
- var gy = g.pheight - (g.mouse_y - g.top_margin) + 3;
- if (gx >= 0 && gx <= g.pwidth && gy >= 0 && gy <= g.pheight) {
- //g.sch.message('button: '+event.button+', which: '+event.which);
- g.cursor1_x = gx;
- } else {
- g.cursor1_x = undefined;
- g.cursor2_x = undefined;
- }
-
- redraw_plot(g);
- }
-
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Parts bin
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- // one instance will be created for each part in the parts bin
- function Part(sch) {
- this.sch = sch;
- this.component = undefined;
- this.selected = false;
-
- // set up canvas
- this.canvas = document.createElement("canvas");
- this.canvas.style.borderStyle = "solid";
- this.canvas.style.borderWidth = "1px";
- this.canvas.style.borderColor = background_style;
- //this.canvas.style.position = 'absolute';
- this.canvas.style.cursor = "default";
- this.canvas.height = part_w;
- this.canvas.width = part_h;
- this.canvas.xpart = this;
-
- this.canvas.addEventListener("mouseover", part_enter, false);
- this.canvas.addEventListener("mouseout", part_leave, false);
- this.canvas.addEventListener("mousedown", part_mouse_down, false);
- this.canvas.addEventListener("mouseup", part_mouse_up, false);
-
- // make the part "clickable" by registering a dummy click handler
- // this should make things work on the iPad
- this.canvas.addEventListener("click", function () {}, false);
- }
-
- Part.prototype.set_location = function (left, top) {
- this.canvas.style.left = left + "px";
- this.canvas.style.top = top + "px";
- };
-
- Part.prototype.right = function () {
- return this.canvas.offsetLeft + this.canvas.offsetWidth;
- };
-
- Part.prototype.bottom = function () {
- return this.canvas.offsetTop + this.canvas.offsetHeight;
- };
-
- Part.prototype.set_component = function (component, tip) {
- component.sch = this;
- this.component = component;
- this.tip = tip;
-
- // figure out scaling and centering of parts icon
- var b = component.bounding_box;
- var dx = b[2] - b[0];
- var dy = b[3] - b[1];
- this.scale = 0.8; //Math.min(part_w/(1.2*dx),part_h/(1.2*dy));
- this.origin_x = b[0] + dx / 2.0 - part_w / (2.0 * this.scale);
- this.origin_y = b[1] + dy / 2.0 - part_h / (2.0 * this.scale);
-
- this.redraw();
- };
-
- Part.prototype.redraw = function (part) {
- var c = this.canvas.getContext("2d");
-
- // paint background color
- c.fillStyle = this.selected ? selected_style : background_style;
- c.fillRect(0, 0, part_w, part_h);
-
- if (this.component) this.component.draw(c);
- };
-
- Part.prototype.select = function (which) {
- this.selected = which;
- this.redraw();
- };
-
- Part.prototype.update_connection_point = function (cp, old_location) {
- // no connection points in the parts bin
- };
-
- Part.prototype.moveTo = function (c, x, y) {
- c.moveTo((x - this.origin_x) * this.scale, (y - this.origin_y) * this.scale);
- };
-
- Part.prototype.lineTo = function (c, x, y) {
- c.lineTo((x - this.origin_x) * this.scale, (y - this.origin_y) * this.scale);
- };
-
- Part.prototype.draw_line = function (c, x1, y1, x2, y2, width) {
- c.lineWidth = width * this.scale;
- c.beginPath();
- c.moveTo((x1 - this.origin_x) * this.scale, (y1 - this.origin_y) * this.scale);
- c.lineTo((x2 - this.origin_x) * this.scale, (y2 - this.origin_y) * this.scale);
- c.stroke();
- };
-
- Part.prototype.draw_arc = function (c, x, y, radius, start_radians, end_radians, anticlockwise, width, filled) {
- c.lineWidth = width * this.scale;
- c.beginPath();
- c.arc(
- (x - this.origin_x) * this.scale,
- (y - this.origin_y) * this.scale,
- radius * this.scale,
- start_radians,
- end_radians,
- anticlockwise,
- );
- if (filled) c.fill();
- else c.stroke();
- };
-
- Part.prototype.draw_text = function (c, text, x, y, size) {
- // no text displayed for the parts icon
- };
-
- function part_enter(event) {
- if (!event) event = window.event;
- var canvas = window.event ? event.srcElement : event.target;
- var part = canvas.xpart;
-
- // avoid Chrome bug that changes to text cursor whenever
- // drag starts. We'll restore the default handler at
- // the appropriate point so behavior in other parts of
- // the document are unaffected.
- //part.sch.saved_onselectstart = document.onselectstart;
- //document.onselectstart = function () { return false; };
-
- canvas.style.borderColor = normal_style;
- part.sch.message(part.tip + ": drag onto diagram to insert");
- return false;
- }
-
- function part_leave(event) {
- if (!event) event = window.event;
- var canvas = window.event ? event.srcElement : event.target;
- var part = canvas.xpart;
-
- if (typeof part.sch.new_part == "undefined") {
- // leaving with no part selected? revert handler
- //document.onselectstart = part.sch.saved_onselectstart;
- }
-
- canvas.style.borderColor = background_style;
- part.sch.message("");
- return false;
- }
-
- function part_mouse_down(event) {
- if (!event) event = window.event;
- var part = window.event ? event.srcElement.xpart : event.target.xpart;
-
- part.select(true);
- part.sch.new_part = part;
- return false;
- }
-
- function part_mouse_up(event) {
- if (!event) event = window.event;
- var part = window.event ? event.srcElement.xpart : event.target.xpart;
-
- part.select(false);
- part.sch.new_part = undefined;
- return false;
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- // Rectangle helper functions
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- // rect is an array of the form [left,top,right,bottom]
-
- // ensure left < right, top < bottom
- function canonicalize(r) {
- var temp;
-
- // canonicalize bounding box
- if (r[0] > r[2]) {
- temp = r[0];
- r[0] = r[2];
- r[2] = temp;
- }
- if (r[1] > r[3]) {
- temp = r[1];
- r[1] = r[3];
- r[3] = temp;
- }
- }
-
- function between(x, x1, x2) {
- return x1 <= x && x <= x2;
- }
-
- function inside(rect, x, y) {
- return between(x, rect[0], rect[2]) && between(y, rect[1], rect[3]);
- }
-
- // only works for manhattan rectangles
- function intersect(r1, r2) {
- // look for non-intersection, negate result
- var result = !(r2[0] > r1[2] || r2[2] < r1[0] || r2[1] > r1[3] || r2[3] < r1[1]);
-
- // if I try to return the above expression, javascript returns undefined!!!
- return result;
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- // Component base class
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- function Component(type, x, y, rotation) {
- this.sch = undefined;
- this.type = type;
- this.x = x;
- this.y = y;
- this.rotation = rotation;
- this.selected = false;
- this.properties = [];
- this.bounding_box = [0, 0, 0, 0]; // in device coords [left,top,right,bottom]
- this.bbox = this.bounding_box; // in absolute coords
- this.connections = [];
- }
-
- Component.prototype.json = function (index) {
- this.properties["_json_"] = index; // remember where we are in the JSON list
-
- var props = {};
- for (var p in this.properties) props[p] = this.properties[p];
-
- var conns = [];
- for (var i = 0; i < this.connections.length; i++) conns.push(this.connections[i].json());
-
- var json = [this.type, [this.x, this.y, this.rotation], props, conns];
- return json;
- };
-
- Component.prototype.add_connection = function (offset_x, offset_y) {
- this.connections.push(new ConnectionPoint(this, offset_x, offset_y));
- };
-
- Component.prototype.update_coords = function () {
- var x = this.x;
- var y = this.y;
-
- // update bbox
- var b = this.bounding_box;
- this.bbox[0] = this.transform_x(b[0], b[1]) + x;
- this.bbox[1] = this.transform_y(b[0], b[1]) + y;
- this.bbox[2] = this.transform_x(b[2], b[3]) + x;
- this.bbox[3] = this.transform_y(b[2], b[3]) + y;
- canonicalize(this.bbox);
-
- // update connections
- for (var i = this.connections.length - 1; i >= 0; --i) this.connections[i].update_location();
- };
-
- Component.prototype.rotate = function (amount) {
- var old_rotation = this.rotation;
- this.rotation = (this.rotation + amount) % 8;
- this.update_coords();
-
- // create an undoable edit record here
- // using old_rotation
- };
-
- Component.prototype.move_begin = function () {
- // remember where we started this move
- this.move_x = this.x;
- this.move_y = this.y;
- };
-
- Component.prototype.move = function (dx, dy) {
- // update coordinates
- this.x += dx;
- this.y += dy;
- this.update_coords();
- };
-
- Component.prototype.move_end = function () {
- var dx = this.x - this.move_x;
- var dy = this.y - this.move_y;
-
- if (dx != 0 || dy != 0) {
- // create an undoable edit record here
-
- this.sch.check_wires(this);
- }
- };
-
- Component.prototype.add = function (sch) {
- this.sch = sch; // we now belong to a schematic!
- sch.add_component(this);
- this.update_coords();
- };
-
- Component.prototype.remove = function () {
- // remove connection points from schematic
- for (var i = this.connections.length - 1; i >= 0; --i) {
- var cp = this.connections[i];
- this.sch.remove_connection_point(cp, cp.location);
- }
-
- // remove component from schematic
- this.sch.remove_component(this);
- this.sch = undefined;
-
- // create an undoable edit record here
- };
-
- Component.prototype.transform_x = function (x, y) {
- var rot = this.rotation;
- if (rot == 0 || rot == 6) return x;
- else if (rot == 1 || rot == 5) return -y;
- else if (rot == 2 || rot == 4) return -x;
- else return y;
- };
-
- Component.prototype.transform_y = function (x, y) {
- var rot = this.rotation;
- if (rot == 1 || rot == 7) return x;
- else if (rot == 2 || rot == 6) return -y;
- else if (rot == 3 || rot == 5) return -x;
- else return y;
- };
-
- Component.prototype.moveTo = function (c, x, y) {
- var nx = this.transform_x(x, y) + this.x;
- var ny = this.transform_y(x, y) + this.y;
- this.sch.moveTo(c, nx, ny);
- };
-
- Component.prototype.lineTo = function (c, x, y) {
- var nx = this.transform_x(x, y) + this.x;
- var ny = this.transform_y(x, y) + this.y;
- this.sch.lineTo(c, nx, ny);
- };
-
- Component.prototype.draw_line = function (c, x1, y1, x2, y2) {
- c.strokeStyle = this.selected ? selected_style : this.type == "w" ? normal_style : component_style;
- var nx1 = this.transform_x(x1, y1) + this.x;
- var ny1 = this.transform_y(x1, y1) + this.y;
- var nx2 = this.transform_x(x2, y2) + this.x;
- var ny2 = this.transform_y(x2, y2) + this.y;
- this.sch.draw_line(c, nx1, ny1, nx2, ny2, 1);
- };
-
- Component.prototype.draw_circle = function (c, x, y, radius, filled) {
- if (filled) c.fillStyle = this.selected ? selected_style : normal_style;
- else c.strokeStyle = this.selected ? selected_style : this.type == "w" ? normal_style : component_style;
- var nx = this.transform_x(x, y) + this.x;
- var ny = this.transform_y(x, y) + this.y;
-
- this.sch.draw_arc(c, nx, ny, radius, 0, 2 * Math.PI, false, 1, filled);
- };
-
- var rot_angle = [
- 0.0, // NORTH (identity)
- Math.PI / 2, // EAST (rot270)
- Math.PI, // SOUTH (rot180)
- (3 * Math.PI) / 2, // WEST (rot90)
- 0.0, // RNORTH (negy)
- Math.PI / 2, // REAST (int-neg)
- Math.PI, // RSOUTH (negx)
- (3 * Math.PI) / 2, // RWEST (int-pos)
- ];
-
- Component.prototype.draw_arc = function (c, x, y, radius, start_radians, end_radians) {
- c.strokeStyle = this.selected ? selected_style : this.type == "w" ? normal_style : component_style;
- var nx = this.transform_x(x, y) + this.x;
- var ny = this.transform_y(x, y) + this.y;
- this.sch.draw_arc(
- c,
- nx,
- ny,
- radius,
- start_radians + rot_angle[this.rotation],
- end_radians + rot_angle[this.rotation],
- false,
- 1,
- false,
- );
- };
-
- Component.prototype.draw = function (c) {
- /*
- for (var i = this.connections.length - 1; i >= 0; --i) {
- var cp = this.connections[i];
- cp.draw_x(c);
- }
- */
- };
-
- // result of rotating an alignment [rot*9 + align]
- var aOrient = [
- 0,
- 1,
- 2,
- 3,
- 4,
- 5,
- 6,
- 7,
- 8, // NORTH (identity)
- 2,
- 5,
- 8,
- 1,
- 4,
- 7,
- 0,
- 3,
- 6, // EAST (rot270)
- 8,
- 7,
- 6,
- 5,
- 4,
- 3,
- 2,
- 1,
- 0, // SOUTH (rot180)
- 6,
- 3,
- 0,
- 7,
- 4,
- 1,
- 8,
- 5,
- 3, // WEST (rot90)
- 2,
- 1,
- 0,
- 5,
- 4,
- 3,
- 8,
- 7,
- 6, // RNORTH (negy)
- 8,
- 5,
- 2,
- 7,
- 4,
- 1,
- 6,
- 3,
- 0, // REAST (int-neg)
- 6,
- 7,
- 8,
- 3,
- 4,
- 5,
- 0,
- 1,
- 2, // RSOUTH (negx)
- 0,
- 3,
- 6,
- 1,
- 4,
- 7,
- 2,
- 5,
- 8, // RWEST (int-pos)
- ];
-
- var textAlign = ["left", "center", "right", "left", "center", "right", "left", "center", "right"];
-
- var textBaseline = ["top", "top", "top", "middle", "middle", "middle", "bottom", "bottom", "bottom"];
-
- Component.prototype.draw_text = function (c, text, x, y, alignment, size, fill) {
- var a = aOrient[this.rotation * 9 + alignment];
- c.textAlign = textAlign[a];
- c.textBaseline = textBaseline[a];
- if (fill == undefined) c.fillStyle = this.selected ? selected_style : normal_style;
- else c.fillStyle = fill;
- this.sch.draw_text(c, text, this.transform_x(x, y) + this.x, this.transform_y(x, y) + this.y, size);
- };
-
- Component.prototype.set_select = function (which) {
- if (which != this.selected) {
- this.selected = which;
- // create an undoable edit record here
- }
- };
-
- Component.prototype.select = function (x, y, shiftKey) {
- this.was_previously_selected = this.selected;
- if (this.near(x, y)) {
- this.set_select(shiftKey ? !this.selected : true);
- return true;
- } else return false;
- };
-
- Component.prototype.select_rect = function (s) {
- this.was_previously_selected = this.selected;
- if (intersect(this.bbox, s)) this.set_select(true);
- };
-
- // if connection point of component c bisects the
- // wire represented by this compononent, return that
- // connection point. Otherwise return null.
- Component.prototype.bisect = function (c) {
- return null;
- };
-
- // does mouse click fall on this component?
- Component.prototype.near = function (x, y) {
- return inside(this.bbox, x, y);
- };
-
- Component.prototype.edit_properties = function (x, y) {
- if (this.near(x, y)) {
- // make an widget for each property
- var fields = [];
- for (var i in this.properties)
- // underscore at beginning of property name => system property
- if (i.charAt(0) != "_") fields[i] = build_input("text", 10, this.properties[i]);
-
- var content = build_table(fields);
- content.fields = fields;
- content.component = this;
-
- this.sch.dialog("Edit Properties", content, function (content) {
- for (var i in content.fields) content.component.properties[i] = content.fields[i].value;
- content.component.sch.redraw_background();
- });
- return true;
- } else return false;
- };
-
- Component.prototype.clear_labels = function () {
- for (var i = this.connections.length - 1; i >= 0; --i) {
- this.connections[i].clear_label();
- }
- };
-
- // default action: don't propagate label
- Component.prototype.propagate_label = function (label) {};
-
- // give components a chance to generate default labels for their connection(s)
- // default action: do nothing
- Component.prototype.add_default_labels = function () {};
-
- // component should generate labels for all unlabeled connections
- Component.prototype.label_connections = function () {
- for (var i = this.connections.length - 1; i >= 0; --i) {
- var cp = this.connections[i];
- if (!cp.label) cp.propagate_label(this.sch.get_next_label());
- }
- };
-
- // default behavior: no probe info
- Component.prototype.probe_info = function () {
- return undefined;
- };
-
- // default behavior: nothing to display for DC analysis
- Component.prototype.display_current = function (c, vmap) {};
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- // Connection point
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- var connection_point_radius = 2;
-
- function ConnectionPoint(parent, x, y) {
- this.parent = parent;
- this.offset_x = x;
- this.offset_y = y;
- this.location = "";
- this.update_location();
- this.label = undefined;
- }
-
- ConnectionPoint.prototype.toString = function () {
- return edx.StringUtils.interpolate("", {
- offset_x: this.offset_x,
- offset_y: this.offset_y,
- parent: edx.HtmlUtils.ensureHTML(this.parent.toString()),
- });
- };
-
- ConnectionPoint.prototype.json = function () {
- return this.label;
- };
-
- ConnectionPoint.prototype.clear_label = function () {
- this.label = undefined;
- };
-
- ConnectionPoint.prototype.propagate_label = function (label) {
- // should we check if existing label is the same? it should be...
-
- if (this.label === undefined) {
- // label this connection point
- this.label = label;
-
- // propagate label to coincident connection points
- this.parent.sch.propagate_label(label, this.location);
-
- // possibly label other cp's for this device?
- this.parent.propagate_label(label);
- } else if (this.label != "0" && label != "0" && this.label != label)
- alert("Node has two conflicting labels: " + this.label + ", " + label);
- };
-
- ConnectionPoint.prototype.update_location = function () {
- // update location string which we use as a key to find coincident connection points
- var old_location = this.location;
- var parent = this.parent;
- var nx = parent.transform_x(this.offset_x, this.offset_y) + parent.x;
- var ny = parent.transform_y(this.offset_x, this.offset_y) + parent.y;
- this.x = nx;
- this.y = ny;
- this.location = nx + "," + ny;
-
- // add ourselves to the connection list for the new location
- if (parent.sch) parent.sch.update_connection_point(this, old_location);
- };
-
- ConnectionPoint.prototype.coincident = function (x, y) {
- return this.x == x && this.y == y;
- };
-
- ConnectionPoint.prototype.draw = function (c, n) {
- if (n != 2) this.parent.draw_circle(c, this.offset_x, this.offset_y, connection_point_radius, n > 2);
- };
-
- ConnectionPoint.prototype.draw_x = function (c) {
- this.parent.draw_line(c, this.offset_x - 2, this.offset_y - 2, this.offset_x + 2, this.offset_y + 2, grid_style);
- this.parent.draw_line(c, this.offset_x + 2, this.offset_y - 2, this.offset_x - 2, this.offset_y + 2, grid_style);
- };
-
- ConnectionPoint.prototype.display_voltage = function (c, vmap) {
- var v = vmap[this.label];
- if (v != undefined) {
- var label = v.toFixed(2) + "V";
-
- // first draw some solid blocks in the background
- c.globalAlpha = 0.85;
- this.parent.draw_text(c, "\u2588\u2588\u2588", this.offset_x, this.offset_y, 4, annotation_size, element_style);
- c.globalAlpha = 1.0;
-
- // display the node voltage at this connection point
- this.parent.draw_text(c, label, this.offset_x, this.offset_y, 4, annotation_size, annotation_style);
-
- // only display each node voltage once
- delete vmap[this.label];
- }
- };
-
- // see if three connection points are collinear
- function collinear(p1, p2, p3) {
- // from http://mathworld.wolfram.com/Collinear.html
- var area = p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y);
- return area == 0;
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- // Wire
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- var near_distance = 2; // how close to wire counts as "near by"
-
- function Wire(x1, y1, x2, y2) {
- // arbitrarily call x1,y1 the origin
- Component.call(this, "w", x1, y1, 0);
- this.dx = x2 - x1;
- this.dy = y2 - y1;
- this.add_connection(0, 0);
- this.add_connection(this.dx, this.dy);
-
- // compute bounding box (expanded slightly)
- var r = [0, 0, this.dx, this.dy];
- canonicalize(r);
- r[0] -= near_distance;
- r[1] -= near_distance;
- r[2] += near_distance;
- r[3] += near_distance;
- this.bounding_box = r;
- this.update_coords(); // update bbox
-
- // used in selection calculations
- this.len = Math.sqrt(this.dx * this.dx + this.dy * this.dy);
- }
- Wire.prototype = new Component();
- Wire.prototype.constructor = Wire;
-
- Wire.prototype.toString = function () {
- return edx.StringUtils.interpolate("", {
- x: this.x,
- y: this.y,
- x_plus_dx: this.x + this.dx,
- y_plus_dy: this.y + this.dy,
- });
- };
-
- // return connection point at other end of wire from specified cp
- Wire.prototype.other_end = function (cp) {
- if (cp == this.connections[0]) return this.connections[1];
- else if (cp == this.connections[1]) return this.connections[0];
- else return undefined;
- };
-
- Wire.prototype.json = function (index) {
- var json = ["w", [this.x, this.y, this.x + this.dx, this.y + this.dy]];
- return json;
- };
-
- Wire.prototype.draw = function (c) {
- this.draw_line(c, 0, 0, this.dx, this.dy);
- };
-
- Wire.prototype.clone = function (x, y) {
- return new Wire(x, y, x + this.dx, y + this.dy);
- };
-
- Wire.prototype.near = function (x, y) {
- // crude check: (x,y) within expanded bounding box of wire
- if (inside(this.bbox, x, y)) {
- // compute distance between x,y and nearst point on line
- // http://www.allegro.cc/forums/thread/589720
- var D = Math.abs((x - this.x) * this.dy - (y - this.y) * this.dx) / this.len;
- if (D <= near_distance) return true;
- }
- return false;
- };
-
- // selection rectangle selects wire only if it includes
- // one of the end points
- Wire.prototype.select_rect = function (s) {
- this.was_previously_selected = this.selected;
- if (inside(s, this.x, this.y) || inside(s, this.x + this.dx, this.y + this.dy)) this.set_select(true);
- };
-
- // if connection point cp bisects the
- // wire represented by this compononent, return true
- Wire.prototype.bisect_cp = function (cp) {
- var x = cp.x;
- var y = cp.y;
-
- // crude check: (x,y) within expanded bounding box of wire
- if (inside(this.bbox, x, y)) {
- // compute distance between x,y and nearst point on line
- // http://www.allegro.cc/forums/thread/589720
- var D = Math.abs((x - this.x) * this.dy - (y - this.y) * this.dx) / this.len;
- // final check: ensure point isn't an end point of the wire
- if (D < 1 && !this.connections[0].coincident(x, y) && !this.connections[1].coincident(x, y)) return true;
- }
- return false;
- };
-
- // if some connection point of component c bisects the
- // wire represented by this compononent, return that
- // connection point. Otherwise return null.
- Wire.prototype.bisect = function (c) {
- if (c == undefined) return;
- for (var i = c.connections.length - 1; i >= 0; --i) {
- var cp = c.connections[i];
- if (this.bisect_cp(cp)) return cp;
- }
- return null;
- };
-
- Wire.prototype.move_end = function () {
- // look for wires bisected by this wire
- this.sch.check_wires(this);
-
- // look for connection points that might bisect us
- this.sch.check_connection_points(this);
- };
-
- // wires "conduct" their label to the other end
- Wire.prototype.propagate_label = function (label) {
- // don't worry about relabeling a cp, it won't recurse!
- this.connections[0].propagate_label(label);
- this.connections[1].propagate_label(label);
- };
-
- // Wires have no properties to edit
- Wire.prototype.edit_properties = function (x, y) {
- return false;
- };
-
- // some actual component will start the labeling of electrical nodes,
- // so do nothing here
- Wire.prototype.label_connections = function () {};
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- // Ground
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- function Ground(x, y, rotation) {
- Component.call(this, "g", x, y, rotation);
- this.add_connection(0, 0);
- this.bounding_box = [-6, 0, 6, 8];
- this.update_coords();
- }
- Ground.prototype = new Component();
- Ground.prototype.constructor = Ground;
-
- Ground.prototype.toString = function () {
- return edx.StringUtils.interpolate("", {
- x: this.x,
- y: this.y,
- });
- };
-
- Ground.prototype.draw = function (c) {
- Component.prototype.draw.call(this, c); // give superclass a shot
- this.draw_line(c, 0, 0, 0, 8);
- this.draw_line(c, -6, 8, 6, 8);
- };
-
- Ground.prototype.clone = function (x, y) {
- return new Ground(x, y, this.rotation);
- };
-
- // Grounds no properties to edit
- Ground.prototype.edit_properties = function (x, y) {
- return false;
- };
-
- // give components a chance to generate a label for their connection(s)
- // default action: do nothing
- Ground.prototype.add_default_labels = function () {
- this.connections[0].propagate_label("0"); // canonical label for GND node
- };
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- // Label
- //
- ////////////////////////////////////////////////////////////////////////////////
-
- function Label(x, y, rotation, label) {
- Component.call(this, "L", x, y, rotation);
- this.properties["label"] = label ? label : "???";
- this.add_connection(0, 0);
- this.bounding_box = [-2, 0, 2, 8];
- this.update_coords();
- }
- Label.prototype = new Component();
- Label.prototype.constructor = Label;
-
- Label.prototype.toString = function () {
- return edx.StringUtils.interpolate("