title: How can I make automatic the editor window content to be in the window size?
body: <pre><code>using System.Collections;
  using System.Collections.Generic;
  using UnityEditor;
  using UnityEditorInternal;
  using UnityEngine;
  
  public class ConversationsEditorWindow : EditorWindow
  {
      public SerializedObject conversation = null;
  
      private ConversationTrigger _conversationTrigger;
  
      [SerializeField] private ReorderableList conversationsList;
  
      private SerializedProperty _conversations;
  
      private int _currentlySelectedConversationIndex = -1;
      private int newSize = 0;
      private Vector2 scrollPos;
  
      private readonly Dictionary&lt;string, ReorderableList&gt; _dialoguesListDict = new Dictionary&lt;string, ReorderableList&gt;();
      private readonly Dictionary&lt;string, ReorderableList&gt; _sentencesListDict = new Dictionary&lt;string, ReorderableList&gt;();
  
      private SerializedObject itemcopy;
  
      public void Init(SerializedObject _item)
      {
          // Copy the Item targetObject to not lose reference when you
          // click another element on the project window.
          itemcopy = new SerializedObject(_item.targetObject);
          conversation = itemcopy;
  
          // Other things to initialize the window
  
          const int width = 1500;
          const int height = 900;
  
          var x = (Screen.currentResolution.width - width) / 2;
          var y = (Screen.currentResolution.height - height) / 2;
  
          var window = GetWindow&lt;ConversationsEditorWindow&gt;();
          window.position = new Rect(x, y, width, height);
  
          _conversationTrigger = (ConversationTrigger)_item.targetObject;
          _conversations = itemcopy.FindProperty("conversations");
  
          conversationsList = new ReorderableList(itemcopy, _conversations)
          {
              displayAdd = true,
              displayRemove = true,
              draggable = true,
  
              drawHeaderCallback = DrawConversationsHeader,
  
              drawElementCallback = DrawConversationsElement,
  
              onAddCallback = (list) =&gt;
              {
                  SerializedProperty addedElement;
                  // if something is selected add after that element otherwise on the end
                  if (_currentlySelectedConversationIndex &gt;= 0)
                  {
                      list.serializedProperty.InsertArrayElementAtIndex(_currentlySelectedConversationIndex + 1);
                      addedElement = list.serializedProperty.GetArrayElementAtIndex(_currentlySelectedConversationIndex + 1);
                  }
                  else
                  {
                      list.serializedProperty.arraySize++;
                      addedElement = list.serializedProperty.GetArrayElementAtIndex(list.serializedProperty.arraySize - 1);
                  }
  
                  var name = addedElement.FindPropertyRelative("Name");
                  var foldout = addedElement.FindPropertyRelative("Foldout");
                  var dialogues = addedElement.FindPropertyRelative("Dialogues");
  
                  name.stringValue = "";
                  foldout.boolValue = false;
                  dialogues.arraySize = 0;
              },
  
              elementHeightCallback = (index) =&gt;
              {
                  return GetConversationHeight(_conversations.GetArrayElementAtIndex(index));
              }
          };
      }
  
      private void OnGUI()
      {
          itemcopy.Update();
  
          // if there are no elements reset _currentlySelectedConversationIndex
          if (conversationsList.serializedProperty.arraySize - 1 &lt; _currentlySelectedConversationIndex) _currentlySelectedConversationIndex = -1;
  
          EditorGUILayout.LabelField("Conversations", EditorStyles.boldLabel);
          EditorGUI.BeginChangeCheck();
          {
              newSize = EditorGUILayout.IntField(_conversations.arraySize);
          }
          if (EditorGUI.EndChangeCheck())
          {
              if (newSize &gt; _conversations.arraySize)
              {
                  // elements have to be added -&gt; how many?
                  var toAdd = newSize - _conversations.arraySize - 1;
                  // why -1 ? -&gt; We add the first element and set its values to default
                  // now if we simply increase the arraySize for the rest of the elements
                  // they will be all a copy of the first -&gt; all defaults ;)
  
                  // first add one element
                  _conversations.arraySize++;
                  // then get that element
                  var newIndex = _conversations.arraySize - 1;
                  var newElement = _conversations.GetArrayElementAtIndex(newIndex);
  
                  // now reset all properties like
                  var name = newElement.FindPropertyRelative("Name");
                  name.stringValue = "";
  
                  // now for the rest simply increase arraySize
                  _conversations.arraySize += toAdd;
              }
              else
              {
                  // for removing just make sure the arraySize is not under 0
                  _conversations.arraySize = Mathf.Max(newSize, 0);
              }
  
              EditorGUI.FocusTextInControl(null);
          }
  
          scrollPos = EditorGUILayout.BeginScrollView(scrollPos, GUILayout.Height(250));
  
          GUILayout.Space(10);
          conversationsList.DoLayoutList();
  
          EditorGUILayout.EndScrollView();
  
          if (GUILayout.Button("Save Conversations"))
          {
              _conversationTrigger.SaveConversations();
          }
  
          if (GUILayout.Button("Load Conversations"))
          {
              Undo.RecordObject(_conversationTrigger, "Loaded conversations from JSON");
              _conversationTrigger.LoadConversations();
          }
  
          itemcopy.ApplyModifiedProperties();
      }
  
      private void DrawConversationsHeader(Rect rect)
      {
          //EditorGUI.LabelField(rect, "Conversations");
      }
  
      private void DrawDialoguesHeader(Rect rect)
      {
          EditorGUI.LabelField(rect, "Dialogues");
      }
  
      private void DrawSentencesHeader(Rect rect)
      {
          EditorGUI.LabelField(rect, "Sentences");
      }
  
  
      private void DrawConversationsElement(Rect rect, int index, bool isActive, bool isFocused)
      {
          if (isActive) _currentlySelectedConversationIndex = index;
  
          var conversation = _conversations.GetArrayElementAtIndex(index);
  
          var position = new Rect(rect);
  
          var name = conversation.FindPropertyRelative("Name");
          var foldout = conversation.FindPropertyRelative("Foldout");
          var dialogues = conversation.FindPropertyRelative("Dialogues");
          var conversationindex = conversation.FindPropertyRelative("ConversationIndex");
          string dialoguesListKey = conversation.propertyPath;
  
          EditorGUI.indentLevel++;
          {
              // make the label be a foldout
              foldout.boolValue = EditorGUI.Foldout(new Rect(position.x, position.y, 10, EditorGUIUtility.singleLineHeight), foldout.boolValue, "Conversation Name " + (index + 1).ToString(), true);
              name.stringValue = EditorGUI.TextField(new Rect(position.x + 145, position.y, 244, EditorGUIUtility.singleLineHeight), name.stringValue);
  
              if (foldout.boolValue)
              {
                  // draw the name field
                  //name.stringValue = EditorGUI.TextField(new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight), name.stringValue);
                  position.y += EditorGUIUtility.singleLineHeight;
  
                  if (!_dialoguesListDict.ContainsKey(dialoguesListKey))
                  {
                      // create reorderabl list and store it in dict
                      var dialoguesList = new ReorderableList(conversation.serializedObject, dialogues)
                      {
                          displayAdd = true,
                          displayRemove = true,
                          draggable = true,
  
                          drawHeaderCallback = DrawDialoguesHeader,
  
                          drawElementCallback = (convRect, convIndex, convActive, convFocused) =&gt; { DrawDialoguesElement(_dialoguesListDict[dialoguesListKey], convRect, convIndex, convActive, convFocused); },
  
                          elementHeightCallback = (dialogIndex) =&gt;
                          {
                              return GetDialogueHeight(_dialoguesListDict[dialoguesListKey].serializedProperty.GetArrayElementAtIndex(dialogIndex));
                          },
  
                          onAddCallback = (list) =&gt;
                          {
                              list.serializedProperty.arraySize++;
                              var addedElement = list.serializedProperty.GetArrayElementAtIndex(list.serializedProperty.arraySize - 1);
  
                              var newDialoguesName = addedElement.FindPropertyRelative("Name");
                              var newDialoguesFoldout = addedElement.FindPropertyRelative("Foldout");
                              var sentences = addedElement.FindPropertyRelative("Sentences");
  
                              newDialoguesName.stringValue = "";
                              newDialoguesFoldout.boolValue = true;
                              sentences.arraySize = 0;
                          }
                      };
                      _dialoguesListDict[dialoguesListKey] = dialoguesList;
                  }
  
                  _dialoguesListDict[dialoguesListKey].DoList(new Rect(position.x, position.y, position.width, position.height - EditorGUIUtility.singleLineHeight));
              }
  
          }
          EditorGUI.indentLevel--;
      }
  
      private void DrawDialoguesElement(ReorderableList list, Rect rect, int index, bool isActive, bool isFocused)
      {
          if (list == null) return;
  
          var dialog = list.serializedProperty.GetArrayElementAtIndex(index);
  
          var position = new Rect(rect);
  
          var foldout = dialog.FindPropertyRelative("Foldout");
          var name = dialog.FindPropertyRelative("Name");
  
          {
              // make the label be a foldout
              foldout.boolValue = EditorGUI.Foldout(new Rect(position.x, position.y, 10, EditorGUIUtility.singleLineHeight), foldout.boolValue, "Character Name ", true);
              name.stringValue = EditorGUI.TextField(new Rect(position.x + 120, position.y, 244, EditorGUIUtility.singleLineHeight), name.stringValue);
  
              var sentencesListKey = dialog.propertyPath;
              var sentences = dialog.FindPropertyRelative("Sentences");
  
              if (foldout.boolValue)
              {
                  position.y += EditorGUIUtility.singleLineHeight;
  
                  if (!_sentencesListDict.ContainsKey(sentencesListKey))
                  {
                      // create reorderabl list and store it in dict
                      var sentencesList = new ReorderableList(sentences.serializedObject, sentences)
                      {
                          displayAdd = true,
                          displayRemove = true,
                          draggable = true,
  
                          // header for the dialog list
                          drawHeaderCallback = DrawSentencesHeader,
  
                          // how a sentence is displayed
                          drawElementCallback = (sentenceRect, sentenceIndex, sentenceIsActive, sentenceIsFocused) =&gt;
                          {
                              var sentence = sentences.GetArrayElementAtIndex(sentenceIndex);
  
                              // draw simple textArea for sentence
                              sentence.stringValue = EditorGUI.TextArea(sentenceRect, sentence.stringValue);
                          },
  
                          // Sentences have simply a fixed height of 2 lines
                          elementHeight = EditorGUIUtility.singleLineHeight * 2,
  
                          // when a sentence is added
                          onAddCallback = (sentList) =&gt;
                          {
                              sentList.serializedProperty.arraySize++;
                              var addedElement = sentList.serializedProperty.GetArrayElementAtIndex(sentList.serializedProperty.arraySize - 1);
  
                              addedElement.stringValue = "";
                          }
                      };
  
                      // store the created ReorderableList
                      _sentencesListDict[sentencesListKey] = sentencesList;
                  }
  
                  // Draw the list
                  _sentencesListDict[sentencesListKey].DoList(new Rect(position.x, position.y, position.width, position.height - EditorGUIUtility.singleLineHeight));
              }
          }
      }
  
  
      /// &lt;summary&gt;
      /// Returns the height of given Conversation property
      /// &lt;/summary&gt;
      /// &lt;param name="conversation"&gt;&lt;/param&gt;
      /// &lt;returns&gt;height of given Conversation property&lt;/returns&gt;
      private float GetConversationHeight(SerializedProperty conversation)
      {
          var foldout = conversation.FindPropertyRelative("Foldout");
  
          // if not foldout the height is simply 1 line
          var height = EditorGUIUtility.singleLineHeight;
  
          // otherwise we sum up every controls and child heights
          if (foldout.boolValue)
          {
              // we need some more lines:
              //  for the Name field,
              // the list header,
              // the list buttons and a bit buffer
              height += EditorGUIUtility.singleLineHeight * 5;
  
  
              var dialogues = conversation.FindPropertyRelative("Dialogues");
  
              for (var d = 0; d &lt; dialogues.arraySize; d++)
              {
                  var dialog = dialogues.GetArrayElementAtIndex(d);
                  height += GetDialogueHeight(dialog);
              }
          }
  
          return height;
      }
  
      /// &lt;summary&gt;
      /// Returns the height of given Dialogue property
      /// &lt;/summary&gt;
      /// &lt;param name="dialog"&gt;&lt;/param&gt;
      /// &lt;returns&gt;height of given Dialogue property&lt;/returns&gt;
      private float GetDialogueHeight(SerializedProperty dialog)
      {
          var foldout = dialog.FindPropertyRelative("Foldout");
  
          // same game for the dialog if not foldout it is only a single line
          var height = EditorGUIUtility.singleLineHeight;
  
          // otherwise sum up controls and child heights
          if (foldout.boolValue)
          {
              // we need some more lines:
              //  for the Name field,
              // the list header,
              // the list buttons and a bit buffer
              height += EditorGUIUtility.singleLineHeight * 4;
  
              var sentences = dialog.FindPropertyRelative("Sentences");
  
              // the sentences are easier since they always have the same height
              // in this example 2 lines so simply do
              // at least have space for 1 sentences even if there is none
              height += EditorGUIUtility.singleLineHeight * Mathf.Max(1, sentences.arraySize) * 2;
          }
  
          return height;
      }
  </code></pre>
  
  <p>The window size is 1500x900</p>
  
  <p>This is how I open the editor window with a editor script with a button :</p>
  
  <pre><code>using System.Collections;
  using System.Collections.Generic;
  using UnityEditor;
  using UnityEditorInternal;
  using UnityEngine;
  
  [CustomEditor(typeof(ConversationTrigger))]
  public class ConversationTriggerEditor : Editor
  {
          if (GUILayout.Button("Configure Item"))
          {
              ConversationsEditorWindow myWindow = CreateInstance&lt;ConversationsEditorWindow&gt;();
  
              myWindow.minSize = new Vector2(1500, 900);
              myWindow.maxSize = new Vector2(1500, 900);
              myWindow.Init(serializedObject);
  
          }
  }
  </code></pre>
  
  <p>The result is :</p>
  
  <p><a href="https://i.stack.imgur.com/kSj3n.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/kSj3n.jpg" alt="Editor Window"></a></p>
  
  <p>The two buttons save and load should be at the bottom of the window and the whole content should be spread over all the window and maybe even it all should be bigger by size the buttons and text and everything.</p>
  
  <p>But the main problem is that more then half of the window is empty. And I want it to be that size 1500x900</p>