private void addEditorWidget(JiraFieldEditorProvider editor)
        {
            PlvsLogger.log("FieldEditor.addEditorWidget()");

            Controls.Remove(labelInfo);
            editorControl          = editor.Widget;
            editorControl.Location = new Point(MARGIN, MARGIN);
            Controls.Add(editorControl);
            editor.resizeToWidth(Width);

            ClientSize = new Size(editorControl.Width + 2 * MARGIN, editorControl.Height + 2 * MARGIN + (ClientSize.Height - buttonOk.Location.Y));

            Resize += fieldEditorResize;

            if (customWidth != -1 && customHeight != -1)
            {
                Size = new Size(customWidth, customHeight);
            }
        }
        private void fillFields()
        {
            List <JiraField> unsupportedFields = new List <JiraField>();

            foreach (JiraField field in fields)
            {
                JiraFieldEditorProvider editor = null;
                switch (JiraActionFieldType.getFieldTypeForField(field))
                {
                case JiraActionFieldType.WidgetType.SUMMARY:
                    editor = new TextLineFieldEditorProvider(field, field.Values.IsNullOrEmpty() ? "" : field.Values[0], fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.DESCRIPTION:
                    editor = new TextAreaFieldEditorProvider(SmartJiraServerFacade.Instance, issue, field, field.Values.IsNullOrEmpty() ? "" : field.Values[0], fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.ENVIRONMENT:
                    editor = new TextAreaFieldEditorProvider(SmartJiraServerFacade.Instance, issue, field, field.Values.IsNullOrEmpty() ? "" : field.Values[0], fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.ISSUE_TYPE:
                    editor = new NamedEntityComboEditorProvider(issue.Server, field, issue.IssueTypeId, issue.IsSubtask ? subtaskIssueTypes : issueTypes, fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.VERSIONS:
                    editor = new NamedEntityListFieldEditorProvider(field, issue.Versions, versions, fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.FIX_VERSIONS:
                    editor = new NamedEntityListFieldEditorProvider(field, issue.FixVersions, versions, fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.ASSIGNEE:
                    editor = new UserFieldEditorProvider(issue.Server, field, field.Values.IsNullOrEmpty() ? "" : field.Values[0], fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.REPORTER:
                    editor = new UserFieldEditorProvider(issue.Server, field, field.Values.IsNullOrEmpty() ? "" : field.Values[0], fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.DUE_DATE:
                    editor = new DateFieldEditorProvider(issue.ServerLanguage, field, field.Values.IsNullOrEmpty()
                                                                        ? (DateTime?)null
                                                                        : JiraIssueUtils.getDateTimeFromShortString(issue.ServerLanguage, field.Values[0]), fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.COMPONENTS:
                    editor = new NamedEntityListFieldEditorProvider(field, issue.Components, comps, fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.RESOLUTION:
                    SortedDictionary <int, JiraNamedEntity> resolutions = JiraServerCache.Instance.getResolutions(issue.Server);
                    editor = new ResolutionEditorProvider(issue.Server, field, issue.ResolutionId, resolutions != null ? resolutions.Values : null, fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.PRIORITY:
                    editor = new NamedEntityComboEditorProvider(issue.Server, field, issue.PriorityId, JiraServerCache.Instance.getPriorities(issue.Server), fieldValid);
                    break;

                case JiraActionFieldType.WidgetType.TIMETRACKING:
                    editor = new TimeTrackingEditorProvider(field, field.Values.IsNullOrEmpty() ? "" : field.Values[0], fieldValid);
                    break;

// ReSharper disable RedundantCaseLabel
                case JiraActionFieldType.WidgetType.SECURITY:
                case JiraActionFieldType.WidgetType.UNSUPPORTED:
// ReSharper restore RedundantCaseLabel
                default:
                    if (!JiraActionFieldType.isTimeField(field))
                    {
                        unsupportedFields.Add(field);
                    }
                    break;
                }

                if (editor == null)
                {
                    continue;
                }

                addLabel(editor.getFieldLabel(issue, field));

                editor.Widget.Location = new Point(FIELD_X_POS, verticalPosition);
                editor.Widget.TabIndex = tabIndex++;

                panelContent.Controls.Add(editor.Widget);
                verticalPosition += editor.VerticalSkip + MARGIN / 2;
                editors.Add(editor);
            }

            if (unsupportedFields.Count == 0)
            {
                return;
            }

            StringBuilder sb = new StringBuilder();

            sb.Append("Unsupported fields (existing values copied): ");
            foreach (var field in unsupportedFields)
            {
                sb.Append(field.Name).Append(", ");
            }
            textUnsupported = new TextBox
            {
                Multiline   = true,
                BorderStyle = BorderStyle.None,
                ReadOnly    = true,
                WordWrap    = true,
                Text        = sb.ToString().Substring(0, sb.Length - 2),
            };
        }
 private void fieldValid(JiraFieldEditorProvider sender, bool valid)
 {
     updateOkButton();
 }
 public void fieldValid(JiraFieldEditorProvider sender, bool valid)
 {
     Invoke(new MethodInvoker(delegate { buttonOk.Enabled = valid; }));
 }
        private void createEditorWidget(IEnumerable <JiraNamedEntity> versions, IEnumerable <JiraNamedEntity> comps, object rawIssueObject)
        {
            PlvsLogger.log("FieldEditor.createEditorWidget()");

            switch (JiraActionFieldType.getFieldTypeForFieldId(fieldId))
            {
            case JiraActionFieldType.WidgetType.SUMMARY:
                editorProvider = new TextLineFieldEditorProvider(field, issue.Summary, fieldValid);
                break;

            case JiraActionFieldType.WidgetType.DESCRIPTION:
                string descr = JiraIssueUtils.getRawIssueObjectPropertyValue <string>(rawIssueObject, "description") ?? "";
                editorProvider = new TextAreaFieldEditorProvider(facade, issue, field, descr, fieldValid);
                break;

            case JiraActionFieldType.WidgetType.ENVIRONMENT:
                string env = JiraIssueUtils.getRawIssueObjectPropertyValue <string>(rawIssueObject, "environment") ?? "";
                editorProvider = new TextAreaFieldEditorProvider(facade, issue, field, env, fieldValid);
                break;

            case JiraActionFieldType.WidgetType.VERSIONS:
                editorProvider = new NamedEntityListFieldEditorProvider(field, issue.Versions, versions, fieldValid);
                break;

            case JiraActionFieldType.WidgetType.FIX_VERSIONS:
                editorProvider = new NamedEntityListFieldEditorProvider(field, issue.FixVersions, versions, fieldValid);
                break;

            case JiraActionFieldType.WidgetType.ASSIGNEE:
                editorProvider = new UserFieldEditorProvider(issue.Server, field,
                                                             field.Values.IsNullOrEmpty() ? "" : field.Values[0], fieldValid, true);
                break;

            case JiraActionFieldType.WidgetType.COMPONENTS:
                editorProvider = new NamedEntityListFieldEditorProvider(field, issue.Components, comps, fieldValid);
                break;

            case JiraActionFieldType.WidgetType.PRIORITY:
                editorProvider = new NamedEntityComboEditorProvider(issue.Server, field, issue.PriorityId,
                                                                    JiraServerCache.Instance.getPriorities(issue.Server),
                                                                    fieldValid);
                break;

            case JiraActionFieldType.WidgetType.TIMETRACKING:
                List <JiraField> fields = JiraActionFieldType.fillFieldValues(issue, rawIssueObject, new List <JiraField> {
                    field
                });
                editorProvider = new TimeTrackingEditorProvider(field, fields[0].Values[0], fieldValid);
                break;

            default:
                MessageBox.Show("Unsupported field type selected for editing",
                                Constants.ERROR_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
                Close();
                break;
            }

            buttonCancel.Enabled = true;
            buttonOk.Enabled     = editorProvider != null ? editorProvider.FieldValid : false;
            if (editorProvider != null)
            {
                addEditorWidget(editorProvider);
            }
        }