Autosize / Layout/ru: what changed
Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.
| Old | New | Line | |
|---|---|---|---|
| 1 | 1 | # Введение | |
| 2 | 2 | ||
| 3 | 3 | LCL может автоматически изменять размер и положение элемента управления, поэтому он адаптируется к изменениям шрифта, темы и текста или другого содержимого. Если вы хотите запустить программу на нескольких платформах, или если ваши подписи доступны на нескольких языках, то ваши средства управления должны правильно адаптироваться к своей среде. LCL позволяет не только сделать быстрый начальный дизайн (перемещение элементов управления на форму с помощью мыши), но и позже установить несколько ключевых свойств, которые сделают регуляторы автоматически адаптироваться впоследствии измененным содержанием и т.д. | |
| 4 | 4 | ||
| 5 | 5 | - Фиксированный дизайн (Fixed design): это значение по умолчанию при размещении элемента управления в дизайнере форм. Положение элемента управления фиксируется относительно его родителя. Размер и положение элемента управления (Left, Top) полностью изменяются программистом. Вы можете перемещать элемент с помощью мыши и изменять его размер свободно. | |
| 6 | 6 | - [[Autosize / Layout/ru|Выравнивание (Aligned)]]: выравненные элементы управления заполняют оставшееся пространство родителя вверху, снизу, слева или справа, или заполняют всё оставшееся пространство. | |
| 7 | 7 | - [[Autosize / Layout/ru|Привязка (Anchored)]]: вы можете закрепить стороны элемента управления (слева, сверху, справа, снизу) с его родителем или с другим элементот управления. Закрепление: LCL попытается оставаться на таком же расстоянии от точки привязки. | |
| 8 | 8 | - [[Autosize / Layout/ru|Разметка (Layout)]]: элементы управления могут быть автоматически выровнены по строкам и столбцам (например, TRadioGroup) | |
| 9 | 9 | - [[Autosize / Layout/ru|Пользовательская разметка через OnResize/OnChangeBounds]]: можно выровнять элементы управления самостоятельно в коде, используя события OnResize и OnChangeBounds. | |
| 10 | 10 | - [[Autosize / Layout/ru|Пользовательские элементы управления]]: написав собственные элементы управления, вы можете переопределить почти каждое поведение LCL как вы хотите. | |
| 11 | 11 | ||
| 12 | 12 | ## Правила приоритета | |
| 13 | 13 | ||
| 14 | 14 | 1. Constraints (Ограничения) | |
| 15 | 15 | 2. Align (Выравнивание) | |
| 16 | 16 | 3. Anchors(Привязки) | |
| 17 | 17 | 4. ChildSizing.Layout | |
| 18 | 18 | 5. AutoSize (Автомасштаб элемента) | |
| 19 | 19 | 6. События OnResize, OnChangeBounds - однако, если вы установите границы, которые конфликтуют с вышеуказанными правилами, то это создаст бесконечный цикл | |
| 20 | 20 | ||
| 21 | 21 | ## Общие свойства | |
| 22 | 22 | ||
| 23 | 23 | Чтобы настроить автоматическое изменение размера, можно изменить несколько основных свойств : | |
| 24 | 24 | ||
| 25 | 25 | - Left, Top, Width, Height | |
| 26 | 26 | - AutoSize: Автомасштаб, указывает LCL автоматически изменить ширину и высоту элемента управления | |
| 27 | 27 | - [[Autosize / Layout/ru|Anchors]]: позволяет создавать зависимости, например, чтобы привязать ComboBox к правой стороне \#Label. | |
| 28 | 28 | - Align | |
| 29 | 29 | - Constraints: позволяет установить минимум и максимум для ширины и высоты | |
| 30 | 30 | - [[Autosize / Layout/ru|BorderSpacing]]: позволяет установить расстояние между привязанными элементами управления | |
| 31 | 31 | - [[Autosize / Layout/ru|ChildSizing]]: позволяет установить расположение и расстояние дочерних элементов управления | |
| 32 | 32 | ||
| 33 | 33 | Внутренние алгоритмы объясняются здесь: [[LCL AutoSizing]]. | |
| 34 | 34 | ||
| 35 | 35 | # Фиксированный дизайн | |
| 36 | 36 | ||
| 37 | 37 | Фиксированный дизайн установлен по умолчанию. Якорь установлен в значение `[akLeft, akTop]`, что означает, значения Top и Left не будут изменяться LCL. Если значение `AutoSize` равно False, LCL не изменяет ширину или высоту. Если значение `AutoSize` равно True, то ширина и высота изменяются по размеру содержимого. Например, `TLabel.AutoSize` умолчанию True, поэтому при изменении текста в нем будет соответственно изменяться размер и `TLabel`, чтобы измененный текст поместился в контроле полностью. `TButton.AutoSize` умолчанию установлен в False, таким образом изменение надписи на кнопке не изменит размеры кнопки. При установке значения `Button.AutoSize` в True, кнопка будет уменьшаться или увеличиваться каждый раз при изменении `Caption` на кнопке или при изменении шрифта или темы. Обратите внимание, что это изменение не всегда происходит сразу. Например во время FormCreate всё автоизмение размера приостанавливается. В любой момент вы можете изменить свойства `Left`, `Top`, `Width` и `Height`. | |
| 38 | 38 | ||
| 39 | 39 | # Автомасштаб | |
| 40 | 40 | ||
| 41 | 41 | `AutoSize`(автомасштаб) - логическое свойство во многих классах; оно позволяет отрегулировать размер элемента управления автоматически, учитывать изменения в тексте или графике, содержащейся в нем, и позволяет наиболее эффективно использовать имеющееся пространство. Это очень важный механизм для создания кроссплатформенных форм. | |
| 42 | 42 | ||
| 43 | 43 | Обычно `AutoSize` равенTrue и делает две вещи для видимого элемента управления: | |
| 44 | 44 | ||
| 45 | 45 | - Если возможно, изменяет управление в нужный размер. Например ширина и высота `TButton` изменяется в соответствии с надписью, в то время как `TEdit` изменяется только в высоту. Ширина `TEdit` не изменяется автоматически. Вы можете изменить ширину `TEdit` самостоятельно.(см GetPreferredSize). | |
| 46 | 46 | - Оно передвигает все фиксированно расположенные дочерние элементы управления так, чтобы самый левый дочерний элемент управления имел Left = 0 (зависит от значения свойства `BorderSpacing`) и самый верхний дочерний элемент управления имел Top = 0. | |
| 47 | 47 | ||
| 48 | 48 | ## Отличия от Delphi | |
| 49 | 49 | ||
| 50 | 50 | - `AutoSize` в Delphi происходит только тогда, когда определенные свойства изменяются, например, когда шрифт из `TLabel` изменяется. В LCL `AutoSize` всегда активен. Delphi позволяет изменить размер `TLabel`, который имеет AutoSize = True, LCL - нет. | |
| 51 | 51 | - Скрытые управления не изменяют размер автоматически. | |
| 52 | 52 | - Изменение размера элемента управления не изменяет размер/расположение заякоренных(привязанных) дочерних элементов управления во время загрузки. Имейте в виду, что конструкторы элементов управления можно вызвать во время загрузки. При использовании `akRight`, `akBottom` якоря с установленными `AnchorSides` и `BorderSpacing` сохраняют правильное расстояние. | |
| 53 | 53 | ||
| 54 | 54 | ## Автомасштаб и изменение размера элемента управления | |
| 55 | 55 | ||
| 56 | 56 | С помощью свойства кнопки `AutoSize=false` задаются фиксированный размер по умолчанию. | |
| 57 | 57 | ||
| 58 | - | ||
| 59 | - | ||
| 60 | - | ||
| 61 | - | ||
| 58 | + |  | |
| 62 | 59 | ||
| 63 | 60 | При установке `AutoSize=true` для каждой кнопки, кнопки растягиваются (или сжимаются) в соответствии с текстом и темой. | |
| 64 | 61 | ||
| 65 | - | ||
| 66 | - | ||
| 67 | - | ||
| 68 | - | ||
| 62 | + |  | |
| 69 | 63 | ||
| 70 | 64 | `AutoSize` не сжимает элемент управления до минимально возможного размера, как вы можете видеть по кнопке OK. Он использует метод `GetPreferredSize` элемента управления, который вызывает метод `CalculatePreferredSize`. По умолчанию реализация `TWinControl` запрашивает виджетсет, который может иметь оптимальную ширину или высоту. Каждый элемент управления может переопределять метод `CalculatePreferredSize`. Например, `TImage` переопределяет его и возвращает размер изображения. Если нет оптимальной ширины (высоты), возвращаемое значение равно 0, и [[LCL]] будет хранить ширину(высоту) элемента управления (если не установлен флаг `ControlStyle = csAutoSize`, который в настоящее время используется только `TPanel`). | |
| 71 | 65 | ||
| 72 | 66 | `TWinControl` вычисляет размер всех своих дочерних элементов управления и использует это для вычисления своего оптимального размера. | |
| 73 | 67 | ||
| 74 | 68 | Когда элемент управления привязан как слева, так и справа, его *ширина фиксирована*. Например, со значением привязки `Align=alTop` элемент управления привязан слева и справа, и соответствует ширине Родителя. Если `Parent.AutoSize` имеет значение true, тогда *Родитель* будет использовать оптимальную ширину элемента управления для вычисления своей собственной оптимальной ширины, и, таким образом, размер элемента управления будет изменен до его оптимальной ширины. См. [[Autosize / Layout/ru|Выравнивание и свойство AutoSize]]. Если значение оптимальной ширины недоступно, используются последние установленные границы (**BaseBounds** или **ReadBounds**). Если никаких ограничений не было установлено, используется метод `GetControlClassDefaultSize`. То же самое для свойства `Height` и привязки сверху и снизу. | |
| 75 | 69 | ||
| 76 | 70 | Ограничения применяются всегда и имеют приоритет. | |
| 77 | 71 | ||
| 78 | 72 | ## Автомасштаб и перемещение дочерних элементов управления | |
| 79 | 73 | ||
| 80 | 74 | Когда *AutoSize=false*, вы можете размещать и перемещать элементы управления свободно: | |
| 81 | 75 | ||
| 82 | - | ||
| 83 | - | ||
| 84 | - | ||
| 85 | - | ||
| 76 | + |  | |
| 86 | 77 | ||
| 87 | 78 | Когда *AutoSize=true*, дочерние элементы управления с фиксированным положением перемещаются с подгонкой. | |
| 88 | 79 | ||
| 89 | 80 | ------------------------------------------------------------------------ | |
| 90 | 81 | ||
| 91 | 82 | Прим.переводчика: на самом деле, перемещаются границы родительского элемента управления так, чтобы дочерние элементы управления с фиксированной относительно друг друга позицией полностью умещались на родительском. При этом родительский элемент управления будет иметь минимально возможный размер. Таким образом, кнопки "перемещаются" относительно верхнего левого угла родительского элемента управления. | |
| 92 | 83 | ||
| 93 | 84 | ------------------------------------------------------------------------ | |
| 94 | 85 | ||
| 95 | - | ||
| 96 | - | ||
| 97 | - | ||
| 98 | - | ||
| 86 | + |  | |
| 99 | 87 | ||
| 100 | 88 | Обе кнопки на панели были перемещены влево и кверху на одно и то же значение так, чтобы сверху и слева не оставалось свободного пространства. Если будут установлены свойства *BorderSpacing\>0* (у кнопок) или *Panel.ChildSizing.LeftRightSpacing\>0* (у панели), то кнопки будут перемещены так, чтобы предопределенный в упомянутых выше свойствах зазор был задействован. | |
| 101 | 89 | ||
| 102 | 90 | Могут быть перемещены дочерние элементы управления только со следующими свойствами: | |
| 103 | 91 | ||
| 104 | 92 | - Anchors=\[akLeft,akRight\] | |
| 105 | 93 | - AnchorSide\[akLeft\].Control=nil | |
| 106 | 94 | - AnchorSide\[akTop\].Control=nil | |
| 107 | 95 | - Align=alNone | |
| 108 | 96 | ||
| 109 | 97 | Перемещение дочерних элементов управления зависит от свойства [[Autosize / Layout|ChildSizing.Layout]]. Разметка применяется в методе *TWinControl.AlignControls*, который может быть полностью или частично переопределен. Например, *TToolBar* переопределяет *ControlsAligned*, чтобы разместить все элементы управления со значением свойства *Align=alCustom*, и задает разметку для перемещения на следующие линии не "вписавшимся" в родительский контрол дочерним элементам управления. | |
| 110 | 98 | ||
| 111 | 99 | Родительские элементы управления могут отключать перемещение дочерних элементов управления установкой у свойства *ControlStyle* флагов *csAutoSizeKeepChildLeft* и *csAutoSizeKeepChildTop* (начиная с 0.9.29). | |
| 112 | 100 | ||
| 113 | 101 | ## Автомасштаб и формы | |
| 114 | 102 | ||
| 115 | 103 | Формы без Parent родительского элемента управления управляются диспетчером окон и, следовательно, не могут свободно размещены или перемещены. Изменение размера в RunTime является лишь рекомендацией, и может быть проигнорировано диспетчером окон. Например, вы можете устанавливать ширину формы 1000 px, а widgetset в ответ изменит размер к 800 px. Если вы устанавливаете свойство *Witdh* в событии формы *OnResize*, то можете создать бесконечное зацикливание. Вот почему LCL TForm отключает *AutoSize*, когда widgetset изменяет размеры формы. | |
| 116 | 104 | ||
| 117 | 105 | Это означает, что действие свойства *AutoSize* для форм приостанавливается, когда пользователь изменяет размер формы или если диспетчеру окон не нравятся текущие границы окна. Например, некоторые диспетчеры окон в Linux имеют такие фишки, как "прилипающие" края, которые изменяют размеры текущего окна в привязке к другим окнам. | |
| 118 | 106 | ||
| 119 | 107 | ### Принудительная установка автомасштабирования формы | |
| 120 | 108 | ||
| 121 | 109 | Вы можете выставить новое значение свойства *AutoSize*, выполнив: | |
| 122 | 110 | ||
| 123 | 111 | ``` pascal | |
| 124 | 112 | Form1.AutoSize := False; | |
| 125 | 113 | Form1.AutoSize := True; | |
| 126 | 114 | ``` | |
| 127 | 115 | ||
| 128 | 116 | ### Расчет размера формы с "автомасштабом" заранее | |
| 129 | 117 | ||
| 130 | 118 | При размещении формы с "автомасштабом" (очевидно, имеется ввиду *Form1.AutoSize=True*) вам может потребоваться получить размер формы, прежде чем показывать ее. Для установки автомасштаба требуется дескриптор (хэндл окна). Вы можете рассчитать размер формы прежде, чем ее показывать, с помощью: | |
| 131 | 119 | ||
| 132 | 120 | ``` pascal | |
| 133 | 121 | Form1.HandleNeeded; | |
| 134 | 122 | Form1.GetPreferredSize(PreferredWidth,PreferredHeight); | |
| 135 | 123 | ``` | |
| 136 | 124 | ||
| 137 | 125 | > **Note:** Диспетчер окон и события формы могут изменять размер окна. Предпочтительный размер не включает рамку окна формы. Это запланированная особенность. | |
| 138 | 126 | ||
| 139 | - | ||
| 140 | - | ||
| 141 | - | ||
| 142 | 127 | # Привязка сторон (Anchoring) | |
| 143 | 128 | ||
| 144 | 129 | Элементы управления для привязки к четырем сторонам имеют свойство *Anchors* с возможными значениями: *akLeft*, *akTop*, *akRight* и *akBottom*. Каждая сторона может быть привязана к родителю или к стороне другого собрата (элемент управления с одним и тем же родителем). Привязка означает **сохранение расстояния** между привязанными элементами управления. По умолчанию значение свойства *Anchors = \[akLeft, akTop\]*. Вертикальные привязки не зависят от горизонтальных привязок. Некоторые свойства, такие как *Align* и *Parent.AutoSize* имеют более высокий приоритет, и могут изменять поведение. | |
| 145 | 130 | ||
| 146 | 131 | ## Привязка к родителю или nil | |
| 147 | 132 | ||
| 148 | 133 | Привязка к nil (по умолчанию) имеет почти такой же эффект, как привязка к родителю. Оба пытаются сохранять расстояние до края клиентской области Родителя. Для привязки к Nil используется расстояние от последнего вызова SetBounds, в то время как для привязки к родительскому используется значение BorderSpacing. | |
| 149 | 134 | ||
| 150 | 135 | Существует четыре комбинации akLeft, akRight (akTop, akBottom): | |
| 151 | 136 | ||
| 152 | 137 | - **akLeft, no akRight**: **Left** контрола фиксирован и не может быть изменен LCL. Правая сторона не закреплена, поэтому она следует за левой стороной. Это означает, что **Width** также сохраняется. | |
| 153 | 138 | - **akLeft and akRight**: **Left** элемента управления фиксирован и не может быть изменен LCL. Правая сторона привязана к правой стороне Родителя. Это означает, что если Родитель увеличен на 100 пикселей, тогда **Width** контрола также будет увеличена на 100 пикселей. | |
| 154 | 139 | - **akRight, no akLeft**: левая сторона управления не закреплена, поэтому она будет следовать за ее правой стороной. Правая сторона закреплена. Это означает, что если Родитель увеличится на 100 пикселей, тогда контроле перемещается вправо на 100 пикселей. | |
| 155 | 140 | - **no akLeft and no akRight**: ни одна из сторон не закреплена. Положение центра контрола масштабируется с родителем. Например, если контрол находится в середине родительского элемента, а родительский элемент увеличен на 100 пикселей, тогда контрол перемещается на 50 пикселей вправо. | |
| 156 | 141 | ||
| 157 | 142 | ### Изменение размера родителя с привязанным контролом | |
| 158 | 143 | ||
| 159 | 144 | При изменении размера родителя все привязанные дочерние контролы перемещаются и/или изменяются по размеру сразу, пока не будет отключено свойство AutoSizing. Например, AutoSizing отключается во время загрузки формы и при создании формы. | |
| 160 | 145 | ||
| 161 | 146 | GroupBox с кнопкой:  | |
| 162 | 147 | ||
| 163 | 148 | Когда GroupBox увеличивается в размере, расстояние до привязанной стороны сохраняется: | |
| 164 | 149 | ||
| 165 | 150 | С akLeft, без akRight:  | |
| 166 | 151 | ||
| 167 | 152 | С akLeft и akRight:  | |
| 168 | 153 | ||
| 169 | 154 | С akRight, без akLeft:  | |
| 170 | 155 | ||
| 171 | 156 | Три кнопки в GroupBox:  | |
| 172 | 157 | ||
| 173 | 158 | Без akLeft и без akRight их центры масштабируются:  | |
| 174 | 159 | ||
| 175 | 160 | **На заметку:** | |
| 176 | 161 | ||
| 177 | 162 | - Загрузка формы похожа на один большой SetBounds. Во время загрузки свойства задаются с использованием значений , сохраненных в файле формы lfm. Имейте в виду, что из-за предков и фреймов может быть несколько файлов lfm. После загрузки LCL активирует autosizing. Привязанные контролы используют ограничение в конце загрузки. Любой шаг между ними игнорируется. | |
| 178 | 163 | - Для пользовательских контролов часто лучше устанавливать AnchorSides вместо Anchors. | |
| 179 | 164 | ||
| 180 | 165 | ### Изменение размера привязанного элемента управления | |
| 181 | 166 | ||
| 182 | 167 | При изменении ширины привязанного элемента управления, например, через Object Inspector или через код *Button1.Width:=3*, вы можете увидеть разницу между привязкой к "родителю" и привязкой к "nil". Привязка к родителю будет изменять размер и перемещать Button1, а привязка к nil будет только изменять размер. Например: | |
| 183 | 168 | ||
| 184 | 169 | #### Привязка к nil | |
| 185 | 170 | ||
| 186 | 171 |  Кнопка Button1 привязана \[akTop,akRight\], AnchorSide\[akRight\].Control=nil | |
| 187 | 172 | ||
| 188 | 173 |  Установка ширины на меньшее значение приведет к сужению кнопки, сохраняя значение *Left* кнопки, увеличивая расстояние от правой стороны кнопки до правого края. | |
| 189 | 174 | ||
| 190 | 175 |  При изменении размера Groupbox кнопка сохранит новое расстояние до правого края. | |
| 191 | 176 | ||
| 192 | 177 | **Объяснение:** установка значения **Width** кнопки эквивалентна вызову SetBounds(**Left**,Top,**NewWidth**,Height). Вот почему значение **Left** сохраняется. Это совместимо с поведением контролов в Delphi. | |
| 193 | 178 | ||
| 194 | 179 | #### Привязка к родителю | |
| 195 | 180 | ||
| 196 | 181 |  Кнопка Button1 привязана \[akTop,akRight\], AnchorSide\[akRight\].Control=Button1.Parent | |
| 197 | 182 | ||
| 198 | 183 |  Установка значения *Width* на меньшее значение приведет к сужению кнопки, сохранив расстояние от ее правой границы до края компонента-родителя и изменив значение *Left* кнопки. | |
| 199 | 184 | ||
| 200 | 185 | ## Привязка к соседу | |
| 201 | 186 | ||
| 202 | 187 | Вы можете привязываться к соседним элементам управления. Следующий пример показывает, что: | |
| 203 | 188 | ||
| 204 | 189 | - вы можете привязать левый край label'а к левому краю кнопки | |
| 205 | 190 | - привязать верхний край label'а к нижнему краю кнопки | |
| 206 | 191 | - привязать центр label'а к центру кнопки\ | |
| 207 | 192 | ||
| 208 | 193 | \ | |
| 209 | 194 | \ | |
| 210 | - | ||
| 195 | + | ||
| 211 | 196 | Подробнее о том, как установить привязку, см. [[Anchor Sides/ru|Стороны привязки]].\ | |
| 212 | - | ||
| 197 | + | ||
| 213 | 198 |  | |
| 214 | 199 | ||
| 215 | 200 | ## Зазор | |
| 216 | 201 | ||
| 217 | 202 | Свойство BorderSpacing(зазор) управляет минимальным количеством пространства вокруг элемента управления. Свойства: | |
| 218 | 203 | ||
| 219 | 204 | - **Around**: эта величина в пикселах, которая добавляется к каждому значению Left, Top, Right, Bottom элемента управления. | |
| 220 | 205 | - **Left**: зазор в пикселах с левой стороны элемента управления | |
| 221 | 206 | - **Top**: зазор в пикселах сверху элемента управления | |
| 222 | 207 | - **Right**: зазор в пикселах с правой стороны элемента управления | |
| 223 | 208 | - **Bottom**: зазор в пикселах под элементом управления | |
| 224 | 209 | - **InnerBorder**: это зазор в пикселях, добавляется дважды к оптимальной ширине и высоте. Некоторые элементы управления переопределяют вычисление и игнорируют это свойство. Пример, где он работает, - TButton. С помощью InnerBorder вы можете сделать кнопку больше, чем необходимо. | |
| 225 | 210 | - **CellAlignHorizontal**: Этот параметр используется в табличных макетах, таких как ChildSizing.Layout=cclLeftToRightThenTopToBottom. Если элемент управления меньше ячейки таблицы, это свойство определяет, как выровнять элемент управления: слева ccaLeftTop, справа ccaRightBottom или посередине ccaCenter. | |
| 226 | 211 | - **CellAlignVertical**: так же, как CellAlignHorizontal, но для вертикального выравнивания. | |
| 227 | 212 | ||
| 228 | 213 | ### Правила зазоров | |
| 229 | 214 | ||
| 230 | 215 | - Значение Around добавляется к зазору для Left,Top,Right,Bottom элемента управления. | |
| 231 | 216 | - Зазор может быть еще больше, если элементы управления имеют ограничения, которые не позволяют им растягиваться. | |
| 232 | 217 | ||
| 233 | 218 | #### Привязка к противоположной стороне | |
| 234 | 219 | ||
| 235 | 220 | Например, правая сторона A к левой стороне B. | |
| 236 | 221 | ||
| 237 | 222 | Используются обе границы A и B. | |
| 238 | 223 | ||
| 239 | 224 | - Горизонтальный зазор между двумя элементами управления (LeftControl, RightControl на общем родителе) он максимален, если: | |
| 240 | 225 | - LeftControl.BorderSpacing.Right + LeftControl.BorderSpacing.Around | |
| 241 | 226 | - RightControl.BorderSpacing.Left + RightControl.BorderSpacing.Around | |
| 242 | 227 | - Parent.ChildSizing.HorizontalSpacing | |
| 243 | 228 | - Вертикальный зазор работает аналогично: между двумя элементами управления (TopControl, BottomControl на общем родителе) он максимален, если: | |
| 244 | 229 | - TopControl.BorderSpacing.Bottom + TopControl.BorderSpacing.Around | |
| 245 | 230 | - BottomControl.BorderSpacing.Top + BottomControl.BorderSpacing.Around | |
| 246 | 231 | - Parent.ChildSizing.VerticalSpacing | |
| 247 | 232 | ||
| 248 | 233 | Например: | |
| 249 | 234 | ||
| 250 | 235 | - если LeftControl.BorderSpacing.Right=3 и LeftControl.BorderSpacing.Around=4, то между двумя элементами управления должно быть не менее 7px | |
| 251 | 236 | - если RightControl.BorderSpacing.Left=4 и RightControl.BorderSpacing.Around=4, то пространство будет не менее 8px | |
| 252 | 237 | - если Parent.ChildSizing.HorizontalSpacing=10, тогда пространство будет не менее 10px | |
| 253 | 238 | ||
| 254 | 239 | #### Привязка к этой же стороне | |
| 255 | 240 | ||
| 256 | 241 | Например, правая сторона A к правой стороне B. | |
| 257 | 242 | ||
| 258 | 243 | - Задействуется только зазор у границы А. | |
| 259 | 244 | - Свойство Parent.ChildSizing.Horizontal/VerticalSpacing не используется. | |
| 260 | 245 | ||
| 261 | 246 | #### Привязка к центру | |
| 262 | 247 | ||
| 263 | 248 | Например, центр А привязан к центру В. | |
| 264 | 249 | ||
| 265 | 250 | Не задействуются ни зазор, ни свойство Parent.ChildSizing.Horizontal/VerticalSpacing. | |
| 266 | 251 | ||
| 267 | 252 | #### Пример | |
| 268 | 253 | ||
| 269 | 254 | Общим примером является привязка Label'а к Edit'у.\ | |
| 270 | 255 | \ | |
| 271 | 256 | Центр Label'а вертикально привязан к Edit'у. Левая сторона Edit'а привязана к правой стороне Label'а. Оба имеют BorderSpacing.Around=6. Это приводит к наличию зазора в 6px между Label'ом и Edit'ом и наличию зазора в 6px слева от Label'а, а также наличию зазора в 6px справа от Edit'а. Также еще существует 6 пикселей зазора выше и ниже Edit'а. | |
| 272 | 257 | ||
| 273 | 258 | - Зазор слева между элементом управления и его родителем (Label1 к GroupBox1) является максимальным, когда | |
| 274 | 259 | - Label1.BorderSpacing.Left + Label1.BorderSpacing.Around | |
| 275 | 260 | - GroupBox1.ChildSizing.LeftTopSpacing | |
| 276 | 261 | ||
| 277 | 262 | - Зазор справа между элементом управления и его родителем (Edit1 к GroupBox1) является максимальным, когда | |
| 278 | 263 | - Edit1.BorderSpacing.Right + Edit1.BorderSpacing.Around | |
| 279 | 264 | - GroupBox1.ChildSizing.RightBottomSpacing | |
| 280 | 265 | ||
| 281 | 266 | - Когда центр элемента управления привязан к другому элементу управления, например, вышеуказанный Label центрирован по вертикали к Edit1, тогда все остальные зазоры игнорируются. | |
| 282 | 267 | ||
| 283 | 268 | - Когда левая сторона элемента управления привязана к левой стороне другого элемента управления (т.е., они выровнены по левой стороне), то расстояние между обеими левыми сторонами является | |
| 284 | 269 | - Control1.BorderSpacing.Left + Control1.BorderSpacing.Around | |
| 285 | 270 | ||
| 286 | 271 | Вот более сложный пример: | |
| 287 | 272 | ||
| 288 | - | ||
| 289 | - | ||
| 290 | - | ||
| 291 | - | ||
| 273 | + |  | |
| 292 | 274 | ||
| 293 | 275 | Важные части кода lfm: | |
| 294 | 276 | ||
| 295 | 277 | ``` pascal | |
| 296 | 278 | object GroupBox1: TGroupBox | |
| 297 | 279 | AutoSize = True | |
| 298 | 280 | Caption = 'GroupBox1' | |
| 299 | 281 | TabOrder = 0 | |
| 300 | 282 | object Label1: TLabel | |
| 301 | 283 | AnchorSideLeft.Control = GroupBox1 | |
| 302 | 284 | AnchorSideTop.Control = Edit1 | |
| 303 | 285 | AnchorSideTop.Side = asrCenter | |
| 304 | 286 | BorderSpacing.Around = 6 | |
| 305 | 287 | Caption = 'Label1' | |
| 306 | 288 | end | |
| 307 | 289 | object Edit1: TEdit | |
| 308 | 290 | AnchorSideLeft.Control = Label1 | |
| 309 | 291 | AnchorSideLeft.Side = asrBottom | |
| 310 | 292 | AnchorSideTop.Control = GroupBox1 | |
| 311 | 293 | AnchorSideRight.Control = GroupBox1 | |
| 312 | 294 | AnchorSideRight.Side = asrBottom | |
| 313 | 295 | Anchors = [akTop, akLeft, akRight] | |
| 314 | 296 | BorderSpacing.Around = 6 | |
| 315 | 297 | TabOrder = 0 | |
| 316 | 298 | Text = 'Edit1' | |
| 317 | 299 | end | |
| 318 | 300 | object Label2: TLabel | |
| 319 | 301 | AnchorSideLeft.Control = GroupBox1 | |
| 320 | 302 | AnchorSideTop.Control = Edit1 | |
| 321 | 303 | AnchorSideTop.Side = asrBottom | |
| 322 | 304 | BorderSpacing.Around = 6 | |
| 323 | 305 | Caption = 'Label2' | |
| 324 | 306 | end | |
| 325 | 307 | object ComboBox1: TComboBox | |
| 326 | 308 | AnchorSideLeft.Control = Label2 | |
| 327 | 309 | AnchorSideTop.Control = Label2 | |
| 328 | 310 | AnchorSideTop.Side = asrBottom | |
| 329 | 311 | AnchorSideRight.Control = GroupBox1 | |
| 330 | 312 | AnchorSideRight.Side = asrBottom | |
| 331 | 313 | Anchors = [akTop, akLeft, akRight] | |
| 332 | 314 | BorderSpacing.Right = 6 | |
| 333 | 315 | TabOrder = 1 | |
| 334 | 316 | Text = 'ComboBox1' | |
| 335 | 317 | end | |
| 336 | 318 | object CheckBox1: TCheckBox | |
| 337 | 319 | AnchorSideLeft.Control = GroupBox1 | |
| 338 | 320 | AnchorSideTop.Control = ComboBox1 | |
| 339 | 321 | AnchorSideTop.Side = asrBottom | |
| 340 | 322 | BorderSpacing.Around = 6 | |
| 341 | 323 | Caption = 'CheckBox1' | |
| 342 | 324 | TabOrder = 2 | |
| 343 | 325 | end | |
| 344 | 326 | object Label3: TLabel | |
| 345 | 327 | AnchorSideLeft.Control = GroupBox1 | |
| 346 | 328 | AnchorSideTop.Control = Edit2 | |
| 347 | 329 | AnchorSideTop.Side = asrCenter | |
| 348 | 330 | BorderSpacing.Around = 6 | |
| 349 | 331 | Caption = 'Label3' | |
| 350 | 332 | end | |
| 351 | 333 | object Edit2: TEdit | |
| 352 | 334 | AnchorSideLeft.Control = Label3 | |
| 353 | 335 | AnchorSideLeft.Side = asrBottom | |
| 354 | 336 | AnchorSideTop.Control = CheckBox1 | |
| 355 | 337 | AnchorSideTop.Side = asrBottom | |
| 356 | 338 | BorderSpacing.Around = 6 | |
| 357 | 339 | TabOrder = 3 | |
| 358 | 340 | Text = 'Edit2' | |
| 359 | 341 | end | |
| 360 | 342 | end | |
| 361 | 343 | ``` | |
| 362 | 344 | ||
| 363 | 345 | ### Зазор и выравнивание | |
| 364 | 346 | ||
| 365 | 347 | Зазор работает с выравниванием. В приведенном ниже примере есть Memo1 с Align=alTop и Memo2 с Align=alCLient. | |
| 366 | 348 | ||
| 367 | 349 | - Обычно два Memo заполняют весь GroupBox. | |
| 368 | 350 | - Но Memo1 имеет BorderSpacing.Around=10, так что вокруг Memo1 будет присутствовать зазор в 10 пикселей. | |
| 369 | 351 | - Memo2 имеет BorderSpacing.Top=20. Зазор между Memo1 и Memo2 будет максимальным, который от Memo1 до Memo2 составит 20px. | |
| 370 | 352 | - Memo2 также имеет и BorderSpacing.Right=50, поэтому справа от Memo2 имеется зазор в 50 пикселей. | |
| 371 | 353 | - GroupBox может задавать зазор по умолчанию для всех своих дочерних элементов управления через значения свойств ChildSizing.LeftRightSpacing/VerticalSpacing/HorizontalSpacing. В этом примере их нет (все упомянутые значения равны 0).\ | |
| 372 | 354 | ||
| 373 | 355 | \ | |
| 374 | - | ||
| 375 | 356 | ||
| 376 | 357 | # Выравнивание (Aligned) | |
| 377 | 358 | ||
| 378 | 359 | Свойство Align(выравнивание) работает почти так же, как в Delphi, и может использоваться для быстрого заполнения какой-нибудь области. Например, чтобы TListBox заполнил всю область своего родителя, установите ListBox1.Align=alClient. Значения выравнивания alTop, alBottom, alLeft и alRight будут размещать элементы управления по возможности без перекрытия друг друга. Это означает, что все элементы управления свойства Align со значением *alLeft, alTop, alBottom, alRight* не будут перекрываться, если есть достаточно места. | |
| 379 | 360 | ||
| 380 | 361 | Алгоритм работает следующим образом: | |
| 381 | 362 | ||
| 382 | 363 | - Сначала все элементы управления с помощью значения свойства alTop помещаются в верхнюю часть клиентской области. Если имеется несколько элементов управления с помощью alTop, последний добавленный/перемещенный будет помещен выше всех. Алгоритм будет стараться избегать перекрытия и сохранять высоту элемента управления, пока ширина всех элементов остается максимальной. Стороны привязки левой, верхней и правой сторон игнорируются. Нижняя сторона привязки работает нормально. Зазор и значение свойства Parent.ChildSize просчитываются, поэтому вы можете задавать зазор вокруг каждого выровненного элемента управления. | |
| 383 | 364 | - Затем все элементы управления с помощью значения свойства alBottom помещаются в нижнюю часть клиентской области. В противном случае оно работает аналогично alTop. | |
| 384 | 365 | - Потом все элементы управления с помощью значения свойства alLeft помещаются слева от клиентской области между элементами управления alTop и alBottom. В противном случае оно работает аналогично alTop. | |
| 385 | 366 | - Затем все элементы управления с помощью значения свойства alRight помещаются справа от клиентской области между элементами управления alTop и alBottom. В противном случае оно работает аналогично alTop. | |
| 386 | 367 | - Если есть элемент управления с установленным свойством alClient, он заполнит оставшуюся часть клиентской области. | |
| 387 | 368 | - Если имеется более одного элемента управления с установленным свойством alClient, они будут помещаться в одно и то же положение, перекрывая друг друга. Используйте свойство Visibility, чтобы определить, какой из них будет показан.\ | |
| 388 | 369 | \ | |
| 389 | 370 | ||
| 390 | - | ||
| 391 | - | ||
| 392 | - | ||
| 393 | - | ||
| 371 | + |  | |
| 394 | 372 | ||
| 395 | 373 | ## Выравнивание и зазоры | |
| 396 | 374 | ||
| 397 | 375 | Величина свойства BorderSpacing и свойства ChildSize родителя применяется к выравниваемым элементам управления. Элемент управления memo ниже имеет Align=alClient.\ | |
| 398 | 376 | ||
| 399 | 377 | ------------------------------------------------------------------------ | |
| 400 | 378 | ||
| 401 | 379 | Прим.переводчика: Ох, уж эти языковые особенности. Автор, очевидно, имел в виду следующее: даже если у дочернего контрола выравнивание выставлено как Align=alClient, то он не будет заполнять собой контрол-родитель полностью, если его свойство BorderSpacing или свойство ChildSize родителя имеют ненулевое значение. | |
| 402 | 380 | ||
| 403 | 381 | ------------------------------------------------------------------------ | |
| 404 | 382 | ||
| 405 | - | ||
| 406 | 383 |  | |
| 407 | 384 | ||
| 408 | 385 | ## Выравнивание и Привязка | |
| 409 | 386 | ||
| 410 | 387 | Свободная сторона выровненного элемента управления (напр., правая сторона **Align=alLeft**) следует правилам привязки. Если привязка не установлена, тогда элемент управления будет сохранять значение своей **Width**. Если привязка установлена, то значение **Width** изменится. | |
| 411 | 388 | ||
| 412 | 389 | ## Выравнивание и свойство AutoSize | |
| 413 | 390 | ||
| 414 | 391 | Элемент управления, выровненный посредством alLeft или alRight, растягивается по вертикали и будет использовать свою ширину, определенную на этапе проектирования формы. Если свойство *AutoSize* установлено в *true*, то значение параметра *Width* будет оптимальной шириной. Кнопка снизу имеет *Align=alRight* и *AutoSize=true*.\ | |
| 415 | 392 |  | |
| 416 | 393 | ||
| 417 | 394 | ## Выравнивание и свойство AutoSize родителя | |
| 418 | 395 | ||
| 419 | 396 | Элемент управления, выровненный посредством alClient, заполняет оставшееся пространство. Родительский элемент управления со значением свойства *AutoSize=true* при этом будет растягиваться или сжиматься так, чтобы впритирку умещать на себе свои дочерние элементы. Что произойдет, если вы объедините эти два свойства? Скажем, вы положили кнопку с Align=alClient на groupbox с AutoSize=true?\ | |
| 420 | 397 | \ | |
| 421 | 398 | LCL использует *предпочтительный размер* кнопок и потому растягивает или сжимает groupbox: | |
| 422 | 399 | ||
| 423 | 400 | \ | |
| 424 | 401 | ||
| 425 | 402 | ## alCustom | |
| 426 | 403 | ||
| 427 | 404 | Это значение Align существует для пользовательских алгоритмов AutoSize и обрабатывается LCL почти как alNone. Элементы управления с установленным значением alCustom не перемещаются LCL, но могут быть перемещены вашим пользовательским элементом управления. Для этого вы должны переопределить методы `CalculatePreferredSize` и `DoAutoSize`. | |
| 428 | 405 | ||
| 429 | 406 | ## Порядок расположения элементов управления с одинаковым значением Align | |
| 430 | 407 | ||
| 431 | 408 | Элементы управления с одинаковым выравниванием добавляются в следующем порядке. Для alLeft элемент управления с наименьшим значением Left, для alTop - наименьшим значением Top, для alRight - наибольшая величина Left+Width, для alBottom - наибольшая величина Top+Height. Если два элемента управления имеют одну и ту же координату, последний из них одерживает победу (вызывая SetBounds или SetParent). Элементы управления могут переопределять CreateControlAlignList, чтобы изменить порядок или переопределить DoAlignChildControls для обработки всего Align. | |
| 432 | 409 | ||
| 433 | 410 | > **Note:** до версии Lazarus 0.9.29 элементы управления размещались в Z-порядке. В некоторых случаях это приводило к переупорядочиванию элементов управления и должно было быть исправлено. Существует одна несовместимость: если вы добавили несколько элементов управления с выравниванием alTop или alLeft без указания границ, все элементы управления будут помещены в координаты 0.0, и, следовательно, последние добавленные окажутся поверх контролов, добавленных ранее. | |
| 434 | 411 | ||
| 435 | - | ||
| 436 | - | ||
| 437 | - | ||
| 438 | 412 | # Разметка (Layout) | |
| 439 | 413 | ||
| 440 | 414 | ## Строки, столбцы и строки | |
| 441 | 415 | ||
| 442 | 416 | Вы можете выравнивать дочерние элементы управления в строках и столбцах, используя свойства ChildSize. Например: | |
| 443 | 417 | ||
| 444 | 418 | - ChildSizing.Layout=cclLeftToRightThenTopToBottom | |
| 445 | 419 | - ChildSizing.ControlsPerLine=3 | |
| 446 | 420 | - AutoSize=false (не изменяет размеры, чтобы подстраиваться под дочерние элементы управления)\ | |
| 447 | 421 | ||
| 448 | - | ||
| 449 | - | ||
| 450 | - | ||
| 451 | - | ||
| 422 | + |  | |
| 452 | 423 | ||
| 453 | 424 | Свойство **Layout** по умолчанию \[имеет значение\] cclNone. Если вы установите **Layout** в другое значение, каждый дочерний элемент, имеющий *нормальные* привязки, будет выровнен. *Нормальные* привязки означают: | |
| 454 | 425 | ||
| 455 | 426 | - Anchors=\[akLeft,akTop\] | |
| 456 | 427 | - AnchorSide\[akLeft\].Control=nil | |
| 457 | 428 | - AnchorSide\[akTop\].Control=nil | |
| 458 | 429 | - Align=alNone | |
| 459 | 430 | ||
| 460 | 431 | Значение **cclLeftToRightThenTopToBottom** будет помещать первый дочерний элемент управление вверху \[и\] слева, второй - \[вверху и\] правее, и так далее. Это - **линия**. Свойство **ControlsPerLine** определяет, когда начинается новая строка. В приведенном выше примере каждая линия (строка) имеет 3 элемента управления. Существует \[всего\] 12 элементов управления, поэтому есть 4 линии (строки), каждая из которых имеет \[по\] 3 элемента управления (столбцы). Если *ControlsPerLine* равен 0, это означает неограниченное количество элементов управления в строке - будет только одна строка со всеми дочерними элементами. | |
| 461 | 432 | ||
| 462 | 433 | Вы можете видеть, что строки имеют разные размеры, каждая строка имеет размер самого большого элемента управления и что элементы управления изменяют размеры до ширины столбца. Между строками нет пробела. Пространство в изображении определяется используемой темой, а не \[приходит\] из LCL. | |
| 463 | 434 | ||
| 464 | 435 | ## Фиксированные зазоры между строками и столбцами | |
| 465 | 436 | ||
| 466 | 437 | Вы можете добавить зазоры между \[строками и столбцами\] этими свойствами: | |
| 467 | 438 | ||
| 468 | 439 | - ChildSizing.VerticalSpacing - зазор между строками | |
| 469 | 440 | - ChildSizing.HorizontalSpacing - зазор между столбцами | |
| 470 | 441 | - ChildSizing.LeftRightSpacing - зазор между левой и правой \[стороной\] *всех* столбцов | |
| 471 | 442 | - ChildSizing.TopBottomSpacing - зазор выше и ниже *всех* столбцов | |
| 472 | 443 | ||
| 473 | 444 | Выше приведенный пример с \[параметрами\]:\ | |
| 474 | 445 | ChildSizing.VerticalSpacing=6,\ | |
| 475 | 446 | ChildSizing.HorizontalSpacing=15,\ | |
| 476 | 447 | ChildSizing.LeftRightSpacing=30,\ | |
| 477 | 448 | ChildSizing.TopBottomSpacing=10,\ | |
| 478 | 449 | AutoSize=true\ | |
| 479 | 450 |  | |
| 480 | 451 | ||
| 481 | 452 | Кроме того, вы можете добавить зазор для каждого элемента управления отдельно с \[помощью\] его свойства BorderSpacing. | |
| 482 | 453 | ||
| 483 | 454 | ## Растяжение | |
| 484 | 455 | ||
| 485 | 456 | Приведенный выше пример изменяет размер GroupBox до необходимых размеров. Если ваш GroupBox имеет фиксированный размер или если он не является свободно изменяемым, например, если GroupBox должен заполнять всю ширину формы, то дочерние элементы должны растягиваться. Существует несколько режимов. Режим по умолчанию *ChildSizing.EnlargeHorizontal=crsAnchorAligning* запрещает что-либо растягивать. Зазоры с правой стороны не будут использоваться. | |
| 486 | 457 | ||
| 487 | 458 | - `crsAnchorAligning` - не использует дополнительные зазоры | |
| 488 | 459 | - `crsScaleChilds` - умножает ширину/высоту на тот же коэффициент | |
| 489 | 460 | - `crsHomogeneousChildResize` - добавляет к каждой ширине/высоте ту же величину | |
| 490 | 461 | - `crsHomogeneousSpaceResize` - добавляет к каждому зазору между дочерними элементами ту же величину | |
| 491 | 462 | ||
| 492 | 463 | ### crsScaleChilds | |
| 493 | 464 | ||
| 494 | 465 | `ChildSizing.EnlargeHorizontal=crsScaleChilds`\ | |
| 495 | 466 | `ChildSizing.EnlargeVertical=crsScaleChilds`\ | |
| 496 | 467 | `AutoSize=false`\ | |
| 497 | 468 |  | |
| 498 | 469 | ||
| 499 | 470 | Например, если значение ClientWidth вдвое больше необходимого, то каждый дочерний элемент будет в два раза больше. | |
| 500 | 471 | ||
| 501 | 472 | ### crsHomogeneousChildResize | |
| 502 | 473 | ||
| 503 | 474 | `ChildSizing.EnlargeHorizontal=crsHomogeneousChildResize`\ | |
| 504 | 475 | `ChildSizing.EnlargeVertical=crsHomogeneousChildResize`\ | |
| 505 | 476 | `AutoSize=false`\ | |
| 506 | 477 |  | |
| 507 | 478 | ||
| 508 | 479 | Например, если ClientWidth на 30 пикселей больше, чем нужно, то каждый дочерний элемент будет на 10 пикселей шире. | |
| 509 | 480 | ||
| 510 | 481 | ### crsHomogeneousSpaceResize | |
| 511 | 482 | ||
| 512 | 483 | `ChildSizing.EnlargeHorizontal=crsHomogeneousSpaceResize`\ | |
| 513 | 484 | `ChildSizing.EnlargeVertical=crsHomogeneousSpaceResize`\ | |
| 514 | 485 | `AutoSize=false`\ | |
| 515 | 486 |  | |
| 516 | 487 | ||
| 517 | 488 | Например, если ClientWidth на 40 пикселов больше, чем необходимо, появится \[дополнительно по\] 10 пикселей зазора слева, справа и между каждым дочерним элементом. | |
| 518 | 489 | ||
| 519 | 490 | ## Сжатие | |
| 520 | 491 | ||
| 521 | 492 | Сжатие работает аналогично растяжению. Вы можете установить разные режимы, если для элементов управления недостаточно места. **ShrinkHorizontal**, **ShrinkVertical**. | |
| 522 | 493 | ||
| 523 | 494 | ## Отдельные ячейки | |
| 524 | 495 | ||
| 525 | 496 | В приведенных выше примерах все элементы управления изменялись одинаково, каждый заполнял всю *ячейку*. *Ячейка* - это пространство в определенной строке и столбце. Обычно элемент управления заполняет все пространство ячейки. Это можно изменить с помощью свойств **BorderSpacing.CellAlignHorizontal** и **BorderSpacing.CellAlignVertical**. | |
| 526 | 497 | ||
| 527 | 498 | Например, установите *BorderSpacing.CellAlignHorizontal* пятой кнопки в **caCenter** \[и\] вы получите следующее: | |
| 528 | 499 | ||
| 529 | - | ||
| 530 | - | ||
| 531 | - | ||
| 532 | - | ||
| 500 | + |  | |
| 533 | 501 | ||
| 534 | 502 | Существует четыре возможных значения для CellAlign Horizontal/CellAlign Vertical: | |
| 535 | 503 | ||
| 536 | 504 | - `caFill`: дочерний элемент управления заполняет всю ширину (высоту) ячейки | |
| 537 | 505 | - `caCenter`: дочерний элемент управления использует свою оптимальную ширину (высоту) и будет центрироваться в ячейке | |
| 538 | 506 | - `caLeftTop`: дочерний элемент управления использует свою оптимальную ширину (высоту) и выравнивается в ячейке слева | |
| 539 | 507 | - `caRightBottom`: дочерний элемент управления использует свою оптимальную ширину (высоту) и будет в ячейке выравниваться по правому краю | |
| 540 | 508 | ||
| 541 | 509 | \ | |
| 542 | - | ||
| 543 | 510 | ||
| 544 | 511 | # Пользовательская разметка через OnResize/OnChangeBounds | |
| 545 | 512 | ||
| 546 | 513 | Иногда разметка LCL недостаточно \[оптимальна\]. В приведенном ниже примере показан GroupBox1 со списком ListBox1 и Memo1. ListBox1 должен заполнить одну треть пространства, Memo1 - забрать все остальное.\ | |
| 547 | 514 |  | |
| 548 | 515 | ||
| 549 | 516 | Всякий раз, когда размер GroupBox изменяется, ListBox1.Width должен составлять одну треть. Для этого определите событие OnResize для GroupBox1: | |
| 550 | 517 | ||
| 551 | 518 | ``` pascal | |
| 552 | 519 | procedure TForm1.GroupBox1Resize(Sender: TObject); | |
| 553 | 520 | begin | |
| 554 | 521 | ListBox1.Width := GroupBox1.ClientWidth div 3; | |
| 555 | 522 | end; | |
| 556 | 523 | ``` | |
| 557 | 524 | ||
| 558 | 525 | ### Общая ошибка: неправильное событие OnResize | |
| 559 | 526 | ||
| 560 | 527 | Не помещайте *весь* свой код изменения размера \[элементов управления\] в событие Form OnResize. Событие Form OnResize вызывается только при изменении размера формы. Дочерние элементы управления (напр., GroupBox1) изменятся позже, поэтому GroupBox1.ClientWidth все еще \[будет\] иметь старое значение во время события FormResize. Вы должны использовать событие GroupBox1.OnResize, чтобы реагировать на изменения GroupBox1.ClientWidth. | |
| 561 | 528 | ||
| 562 | 529 | ### Общая ошибка: Width вместо ClientWidth, AdjustClientRect | |
| 563 | 530 | ||
| 564 | 531 | \[Свойство\] Width - это размер \[элемента управления\], включая рамку. \[Свойство\] ClientWidth - это внутренняя ширина \[элемента управления\] без рамки. Некоторые элементы управления, такие как TPanel, рисуют еще одну рамку. Потом вы используете AdjustClientRect. Тот же пример, но вместо GroupBox1 на Panel1 находится ListBox1: | |
| 565 | 532 | ||
| 566 | 533 | ``` pascal | |
| 567 | 534 | procedure TForm1.Panel1Resize(Sender: TObject); | |
| 568 | 535 | var | |
| 569 | 536 | r: TRect; | |
| 570 | 537 | begin | |
| 571 | 538 | r := Panel1.ClientRect; | |
| 572 | 539 | Panel1.AdjustClientRect(r); | |
| 573 | 540 | ListBox1.Width := (r.Right - r.Left) div 3; | |
| 574 | 541 | end; | |
| 575 | 542 | ``` | |
| 576 | 543 | ||
| 577 | - | ||
| 578 | - | ||
| 579 | - | ||
| 580 | 544 | # Пользовательские элементы управления | |
| 581 | 545 | ||
| 582 | 546 | Когда вы пишете свой собственный элемент управления, вы можете переопределить и тонко настроить многие части автомасштаба LCL. | |
| 583 | 547 | ||
| 584 | 548 | ## SetBounds, ChangeBounds, DoSetBounds | |
| 585 | 549 | ||
| 586 | 550 | **SetBounds** вызывается, когда устанавливаются свойства Left, Top, Width, Height, BoundsRect, или пользователь вызывает его напрямую. SetBounds обновляет BaseBounds и BaseParentClientSize, которые используются \[механизмом\] привязки для сохранения размеров. Например, загрузка формы с TMemo и lfm\[-файлом\], содержащим \[значения параметров\] Left и Width \[компонента\] TMemo, вызывает \[метод\] SetBounds для TMemo два раза. Когда пользователь распахивает окно, SetBounds вызывается для формы, но не для Memo, сохраняя BaseBounds Memo. Если Memo привязан справа, \[значение параметра\] Width \[компонента\] Memo изменяется на основе \[кода методов\] BaseBounds и BaseParentClientSize. Имейте в виду, что данные aLeft, aTop, aWidth, aHeight могут быть недействительными и будут изменены LCL перед применением. Delphi чаще всего называет SetBounds. SetBounds вызывает ChangeBounds с KeepBase=false. | |
| 587 | 551 | ||
| 588 | 552 | **ChangeBounds** вызывается всякий раз, когда позиция или размер элемента управления задаются либо с помощью свойств, либо с помощью \[механизма разметки\] LCL. SetBounds вызывает внутри \[себя\] ChangeBounds с KeepBase=false, в то время как \[механизма разметки\] LCL вызывает его с KeepBase=true. Переопределение этого в коде может изменить предпочтительный размер или изменить размеры других элементов управления. Имейте в виду, что данные aLeft, aTop, aWidth, aHeight могут быть недействительными и будут изменены LCL перед применением. Вы можете вызвать эту функцию. | |
| 589 | 553 | ||
| 590 | 554 | **DoSetBounds** - это функция низкого уровня для установки private-переменных FLeft, FTop, FWidth, FHeight. Не вызывайте эту функцию, \[потому что\] только LCL вызывает ее. Она также обновляет FClientWidth и FClientHeight соответственно. Переопределите ее, чтобы обновить содержимое разметки элемента управления, например полосы прокрутки. Как всегда: не рисуйте здесь, но вызывайте Invalidate и рисуйте в OnPaint или переопределите Paint. | |
| 591 | 555 | ||
| 592 | 556 | **DoAdjustClientRectChange** вызывается LCL и интерфейсом LCL, когда ClientRect изменился, а Width и Height сохранились. | |
| 593 | 557 | ||
| 594 | 558 | **WMSize** существует для совместимости с Delphi/VCL. Он вызывается интерфейсом LCL при каждом изменении границ. | |
| 595 | 559 | ||
| 596 | 560 | ## AdjustClientRect | |
| 597 | 561 | ||
| 598 | 562 | Метод AdjustClientRect может быть переопределен вашими пользовательскими элементами управления и влияет на \[свойства\] Align, ChildSizing.Layout и AnchorSides. Это не влияет на значение Left, Top и не влияет на нормальный \[механизм\] привязки (например, установку). | |
| 599 | 563 | ||
| 600 | 564 | Когда вы хотите нарисовать свою собственную рамку, тогда дочерние элементы управления должны быть выровнены в этой рамке. Например, TPanel рисует рамку и уменьшает клиентскую область, переопределяя метод **AdjustClientRect**: | |
| 601 | 565 | ||
| 602 | 566 | ``` pascal | |
| 603 | 567 | TCustomPanel = class(TCustomControl) | |
| 604 | 568 | ... | |
| 605 | 569 | protected | |
| 606 | 570 | ... | |
| 607 | 571 | procedure AdjustClientRect(var aRect: TRect); override; | |
| 608 | 572 | ... | |
| 609 | 573 | ||
| 610 | 574 | procedure TCustomPanel.AdjustClientRect(var aRect: TRect); | |
| 611 | 575 | var | |
| 612 | 576 | BevelSize: Integer; | |
| 613 | 577 | begin | |
| 614 | 578 | inherited AdjustClientRect(aRect); | |
| 615 | 579 | ||
| 616 | 580 | BevelSize := BorderWidth; | |
| 617 | 581 | if (BevelOuter <> bvNone) then | |
| 618 | 582 | inc(BevelSize, BevelWidth); | |
| 619 | 583 | if (BevelInner <> bvNone) then | |
| 620 | 584 | inc(BevelSize, BevelWidth); | |
| 621 | 585 | ||
| 622 | 586 | InflateRect(aRect, -BevelSize, -BevelSize); | |
| 623 | 587 | end; | |
| 624 | 588 | ``` | |
| 625 | 589 | ||
| 626 | 590 | ### AdjustClientRect и выравнивание | |
| 627 | 591 | ||
| 628 | 592 | AdjustClientRect может использоваться для уменьшения клиентской области, используемой всеми операциями \[автоматической установки\] размера. Например, TPanel использует AdjustClientRect для уменьшения клиентской области посредством \[изменения величины\] зазора: | |
| 629 | 593 | ||
| 630 | - | ||
| 631 | - | ||
| 632 | - | ||
| 633 | - | ||
| 594 | + |  | |
| 634 | 595 | ||
| 635 | 596 | \[Кнопка\] Button1 на скриншоте была создана со \[значением\] Align=alClient. Также \[был\] задействован \[свойство панели\] ChildSizing.Layout. | |
| 636 | 597 | ||
| 637 | 598 | Когда \[дочерний элемент\] привязывается к родительскому элементу через \[свойство\] AnchorSides, также используется параметр AdjustClientRect: | |
| 638 | 599 | ||
| 639 | 600 | ``` pascal | |
| 640 | 601 | Button1.AnchorParallel(akTop,0,Button1.Parent); | |
| 641 | 602 | ``` | |
| 642 | 603 | ||
| 643 | 604 | Верхний край Button1 привязан к верхнему краю клиентской области родителя. Если AdjustClientRect добавляет 3px к \[значению\] Top, Button1.Top будет 3px (3 плюс 0). | |
| 644 | 605 | ||
| 645 | 606 | ## Собственный AutoSize | |
| 646 | 607 | ||
| 647 | 608 | Когда параметру *AutoSize* установлено значение true, элемент управления должен быть изменен до оптимального размера, если это возможно. | |
| 648 | 609 | ||
| 649 | 610 | ### Предпочтительный размер | |
| 650 | 611 | ||
| 651 | 612 | Новый размер выбирается \[механизмом\] LCL через \[метод\] **GetPreferredSize**, который вызывает **CalculatePreferredSize** \[и\] который можно переопределить. Например, давайте опишем **TQuadrat**, который является \[наследником\] TShape, но его высота должна быть равна его ширине: | |
| 652 | 613 | ||
| 653 | 614 | ``` pascal | |
| 654 | 615 | TQuadrat = class(TShape) | |
| 655 | 616 | protected | |
| 656 | 617 | procedure CalculatePreferredSize(var PreferredWidth, | |
| 657 | 618 | PreferredHeight: integer; WithThemeSpace: Boolean); override; | |
| 658 | 619 | end; | |
| 659 | 620 | ... | |
| 660 | 621 | procedure TQuadrat.CalculatePreferredSize(var PreferredWidth, | |
| 661 | 622 | PreferredHeight: integer; WithThemeSpace: Boolean); | |
| 662 | 623 | begin | |
| 663 | 624 | PreferredHeight:=Width; | |
| 664 | 625 | end; | |
| 665 | 626 | ``` | |
| 666 | 627 | ||
| 667 | 628 | Метод CalculatePreferredSize получает два переменных параметра: *PreferredWidth* и *PreferredHeight*. Они по умолчанию равны 0, что означает: нет оптимального размера, поэтому LCL не изменяет размер. Вышеупомянутая функция устанавливает \[свойство\] *PreferredHeight* в текущее \[свойство\] *Width*. Логический параметр *WithThemeSpace* устарел и всегда \[равен\] false. | |
| 668 | 629 | ||
| 669 | 630 | **Важно**: \[метод\] CalculatePreferredSize не должен изменять границы или любое другое значение элемента управления, которое может инициировать \[механизм\] autosize. Это создаст \[бесконечный\] цикл. | |
| 670 | 631 | ||
| 671 | 632 | Вычисление *PreferredWidth/Height* может быть дорогостоящей \[операцией\]. Поэтому LCL кэширует результат до тех пор, пока для элемента управления не будет вызвана \[процедура\] *InvalidatePreferredSize*. В нашем примере *PreferredHeight* зависит от \[параметра\] *Width*, поэтому мы должны \[вызвать\] перерисовку \[элемента управления\], когда изменяется \[параметр\] *Width*: | |
| 672 | 633 | ||
| 673 | 634 | ``` pascal | |
| 674 | 635 | TQuadrat = class(TShape) | |
| 675 | 636 | protected | |
| 676 | 637 | ... | |
| 677 | 638 | procedure DoSetBounds(ALeft, ATop, AWidth, AHeight: integer); override; | |
| 678 | 639 | end; | |
| 679 | 640 | ... | |
| 680 | 641 | procedure TQuadrat.DoSetBounds(ALeft, ATop, AWidth, AHeight: integer); | |
| 681 | 642 | begin | |
| 682 | 643 | inherited DoSetBounds(ALeft, ATop, AWidth, AHeight); | |
| 683 | 644 | InvalidatePreferredSize; | |
| 684 | 645 | // Примечание: здесь [вызов метода] AdjustSize может быть опущен, поскольку LCL делает это после вызова DoSetBounds. | |
| 685 | 646 | end; | |
| 686 | 647 | ``` | |
| 687 | 648 | ||
| 688 | 649 | LCL автоматически активирует \[механизм\] autosizing'а, когда границы изменяются, поэтому пример является полным. | |
| 689 | 650 | ||
| 690 | 651 | По умолчанию TWinControl для реализации CalculatePreferredSize запрашивает виджетсет, который может вернуть оптимальную ширину и/или высоту. Каждый элемент управления может переопределять метод CalculatePreferredSize. Например, TImage переопределяет его и возвращает размер изображения. Если нет оптимальной ширины (высоты), возвращаемое значение \[будет\] равно 0, и LCL будет сохранять текущую \[величину\] Width (Height). Если 0 - допустимый размер для вашего контроля, вы должны присвоить флагу ControlStyle \[значение\] csAutoSize0x0 (ControlStyle:=ControlStyle+\[csAutoSize0x0\];). Примером может служить\элемент управления LCL TPanel. | |
| 691 | 652 | ||
| 692 | 653 | ### AdjustSize | |
| 693 | 654 | ||
| 694 | 655 | Когда предпочтительный размер зависит от нового свойства, то каждый раз, когда свойство изменяется, должен быть вызван \[механизм\] автоматического изменения размера. Например: | |
| 695 | 656 | ||
| 696 | 657 | ``` pascal | |
| 697 | 658 | procedure TQuadrat.SetSubTitle(const AValue: string); | |
| 698 | 659 | begin | |
| 699 | 660 | if FSubTitle = AValue then exit; | |
| 700 | 661 | FSubTitle := AValue; | |
| 701 | 662 | InvalidatePreferredSize; | |
| 702 | 663 | AdjustSize; | |
| 703 | 664 | end; | |
| 704 | 665 | ``` | |
| 705 | 666 | ||
| 706 | - | ||
| 707 | - | ||
| 708 | - | ||
| 709 | 667 | # Сокращение накладных расходов с помощью \[методов\] DisableAutoSizing, EnableAutoSizing | |
| 710 | 668 | ||
| 711 | 669 | Начиная с \[версии\] Lazarus 0.9.29, существует новый алгоритм автоизменения размера, который уменьшает накладные расходы и допускает глубокие вложенные зависимости. До \[версии\] 0.9.28 \[методы\] DisableAlign/EnableAlign и Disable/EnableAutoSize работают только для одного элемента управления и его прямых дочерних контролов. | |
| 712 | 670 | ||
| 713 | 671 | Каждый раз, когда вы меняете \[какое-нибудь\] свойство, LCL запускает \[механизм\] пересчета разметки: | |
| 714 | 672 | ||
| 715 | 673 | ``` pascal | |
| 716 | 674 | Label1.Caption := 'A'; // первый перерасчет | |
| 717 | 675 | Label2.Caption := 'B'; // второй перерасчет | |
| 718 | 676 | ``` | |
| 719 | 677 | ||
| 720 | 678 | Перерасчет будет возбуждать \[механизм вызова\] событий и отправки сообщений. Чтобы уменьшить накладные расходы, вы можете приостановить \[механизм\] автоизменения размера: | |
| 721 | 679 | ||
| 722 | 680 | ``` pascal | |
| 723 | 681 | DisableAutoSizing; | |
| 724 | 682 | try | |
| 725 | 683 | Label1.Caption := 'A'; // нет перерасчета | |
| 726 | 684 | Label2.Caption := 'B'; // нет перерасчета | |
| 727 | 685 | finally | |
| 728 | 686 | EnableAutoSizing; // однократный перерасчет | |
| 729 | 687 | end; | |
| 730 | 688 | ``` | |
| 731 | 689 | ||
| 732 | 690 | Вы должны уравновешивать вызовы Disable/EnableAutoSizing. Автоизменение размера начинается только тогда, когда вызывается EnableAutoSizing после соответствующего (ранее) \[вызова\] DisableAutoSizing. | |
| 733 | 691 | ||
| 734 | 692 | Начиная с \[версии Lazarus\] 0.9.29, Disable/EnableAutoSize работает для всей формы. Это означает, что каждый вызов DisableAutoSizing приостанавливает автоизменение размера для **всех** элементов управления на этой форме. Если вы пишете свой собственный элемент управления, вы можете использовать следующее: | |
| 735 | 693 | ||
| 736 | 694 | ``` pascal | |
| 737 | 695 | procedure TMyRadioGroup.DoSomething; | |
| 738 | 696 | begin | |
| 739 | 697 | DisableAutoSizing; // отключено автоизменение размера не только [для] TRadioGroup, но и [для] всей формы | |
| 740 | 698 | try | |
| 741 | 699 | // удаляем элементы ... | |
| 742 | 700 | // добавляем, тасуем элементы ... | |
| 743 | 701 | // меняем заголовки элементов ... | |
| 744 | 702 | finally | |
| 745 | 703 | EnableAutoSizing; // перерасчет | |
| 746 | 704 | end; | |
| 747 | 705 | end; | |
| 748 | 706 | ``` | |
| 749 | 707 | ||
| 750 | 708 | К чему все это: вам не нужно \[ни о чем\] заботиться. Просто вызовите Disable/EnableAutoSizing. | |
| 751 | 709 | ||
| 752 | 710 | > **Note:** вот так неправильно:\ | |
| 753 | 711 | > \ | |
| 754 | 712 | > | |
| 755 | 713 | > ``` pascal | |
| 756 | 714 | > Button1.DisableAutoSizing; | |
| 757 | 715 | > Label1.EnableAutoSizing; // неверно: каждый элемент управления имеет свой собственный | |
| 758 | 716 | > //счетчик ссылок на автоизменение размера | |
| 759 | 717 | > ``` | |
| 760 | 718 | ||
| 761 | 719 | ## DisableAutoSizing и границы формы | |
| 762 | 720 | ||
| 763 | 721 | DisableAutoSizing имеет еще один полезный эффект при асинхронных менеджерах окон, которые вы \[можете\] встретить в системах Linux. Каждый раз, когда форма изменяет размер или перемещается, \[ее\] границы отправляются в widgetset (DoSendBoundsToInterface). Даже если форма не отображается, дескриптор изменяется. Менеджер окон зачастую рассматривает эти границы только в качестве предложения. У диспетчера окон есть своя логика, и часто используются только границы, переданные первыми. Второе, третье или дальнейшие перемещения могут быть проигнорированы. С помощью параметра DisableAutoSizing вы можете убедиться, что только последние границы отправляются в виджетсет, что делает границы формы более надежными \[для отображения\]. | |
| 764 | 722 | ||
| 765 | 723 | ------------------------------------------------------------------------ | |
| 766 | 724 | ||
| 767 | 725 | Прим.перев.: очевидно, имеется ввиду прерывистый механизм перерисовки границ окна, когда при перетаскивании его края мышью рисуется только рамка новой границы окна, а окончательная перерисовка происходит после отпускания кнопки мыши. | |
| 768 | 726 | ||
| 769 | 727 | ------------------------------------------------------------------------ | |
| 770 | 728 | ||
| 771 | - | ||
| 772 | - | ||
| 773 | - | ||
| 774 | 729 | # Пример: панель кнопок | |
| 775 | 730 | ||
| 776 | 731 | В этом примере сочетаются несколько механизмов компоновки LCL для создания панели с тремя кнопками: кнопка *Help* слева и кнопки *Ok* и *Cancel* справа. Мы хотим, чтобы панель была внизу формы, заполняя всю \[ее\] ширину. Кнопки и панель автоматически изменяют размеры, чтобы соответствовать всем шрифтам и темам. | |
| 777 | 732 | ||
| 778 | 733 | Шаг 1: Создайте панель и установите ее свойство Align в alBottom. Добавьте три TBitBtns. | |
| 779 | 734 | ||
| 780 | - | ||
| 781 | - | ||
| 782 | - | ||
| 783 | - | ||
| 735 | + |  | |
| 784 | 736 | ||
| 785 | 737 | Установите в свойстве *Kind* BitBtns \[соответственные\] отображения глифов. Возможно, вам нужно будет установить свойство GlyphShowMode в gsmAlways\[("отображать всегда")\], чтобы увидеть их на своей платформе. Установите для свойства *AutoSize* \[кнопок\] BitBtn значение *True*, которое уменьшит/увеличит \[ширину\] кнопок для идеального заполнения \[их\] глифами и текстом. В зависимости от вашей темы и платформы вы можете заметить, что кнопки имеют разную высоту. | |
| 786 | 738 | ||
| 787 | - | ||
| 788 | - | ||
| 789 | - | ||
| 790 | - | ||
| 739 | + |  | |
| 791 | 740 | ||
| 792 | 741 | Установите свойство *Align ' кнопки справки в*alLeft*и установите для остальных двух кнопок свойство*Align*в*alRight''. Это увеличит кнопки по вертикали и переместит их в крайнее левое/правое. alLeft/alRight не влияют на ширину, поэтому кнопки используют свою предпочтительную ширину. | |
| 793 | 742 | ||
| 794 | - | ||
| 795 | - | ||
| 796 | - | ||
| 797 | - | ||
| 743 | + |  | |
| 798 | 744 | ||
| 799 | 745 | Высота панели по-прежнему фиксирована. Теперь установите для панели свойство *AutoSize* в *True*. Панель теперь сжимается вертикально, чтобы соответствовать самой высокой кнопке. | |
| 800 | 746 | ||
| 801 | - | ||
| 802 | - | ||
| 803 | - | ||
| 804 | - | ||
| 747 | + |  | |
| 805 | 748 | ||
| 806 | 749 | Кнопка *Ok* имеет короткий заголовок, поэтому кнопка очень маленькая. Установите для кнопки *Constraints.MinWidth* в значение *75*. Теперь кнопка несколько расширится. | |
| 807 | 750 | ||
| 808 | - | ||
| 809 | - | ||
| 810 | - | ||
| 811 | - | ||
| 751 | + |  | |
| 812 | 752 | ||
| 813 | 753 | Теперь добавьте некоторое пространство вокруг кнопок. Установите для панели *ChildSizing.LeftTopSpacing/RightBottomSpacing/HorizontalSpacing* в значение *6*. | |
| 814 | 754 | ||
| 815 | - | ||
| 816 | - | ||
| 817 | - | ||
| 818 | - | ||
| 755 | + |  | |
| 819 | 756 | ||
| 820 | 757 | Наконец, очистите *Caption* панели и установите ее 'BevelOuter*в*bvNone''. | |
| 821 | 758 | ||
| 822 | 759 | \ | |
| 823 | - | ||
| 824 | 760 | ||
| 825 | 761 | # Прокрутка | |
| 826 | 762 | ||
| 827 | 763 | Некоторые элементы управления LCL, такие как *TScrollBox*, *TForm' и*TFrame'', показывают полосы прокрутки, если дочерние элементы управления слишком велики, чтобы поместиться на scrollbox'е, форме или фрейме. Они наследуют это поведение от своего предка **TScrollingWinControl**. | |
| 828 | 764 | ||
| 829 | 765 | Прокручиваемая **логическая клиентская область** элемента управления может быть больше, чем **видимая клиентская область**. **Видимая клиентская область** - это **ClientRect**. Она всегда начинается с \[координат\] 0,0 и его ширина и высота - это внутренняя область. Например, в TGroupBox - это размер области внутри фрейма. Итак, всегда верно следующее: | |
| 830 | 766 | ||
| 831 | 767 | ``` pascal | |
| 832 | 768 | ClientWidth <= Width | |
| 833 | 769 | ClientHeight <= Height | |
| 834 | 770 | ``` | |
| 835 | 771 | ||
| 836 | 772 | **Логическая клиентская область** определяется методом **GetLogicalClientRect**. По умолчанию она совпадает с *ClientRect*. Когда дочерний элемент управления привязан к правой стороне, он использует *логическую клиентская область*. *TScrollingWinControl* переопределяет этот метод и возвращает *Range*\[(диапазон)\] полос прокрутки, если \[логическая клиентская область\] больше, чем *ClientRect*. **Range** можно установить вручную или автоматически с помощью *AutoScroll=true*. Пример для *AutoScroll=true*: | |
| 837 | 773 | ||
| 838 | - | ||
| 839 | - | ||
| 840 | - | ||
| 841 | - | ||
| 774 | + |  | |
| 842 | 775 | ||
| 843 | 776 | Верхняя кнопка имеет фиксированную ширину 200. Нижняя кнопка привязана к правой стороне панели. Поэтому дочерние элементы управления имеют предпочтительную ширину 200. Поскольку панель больше 200, логическая область клиента больше и нижняя кнопка расширяется. | |
| 844 | 777 | ||
| 845 | 778 | Теперь панель сжата, так что ClientWidth становится меньше 200: | |
| 846 | 779 | ||
| 847 | - | ||
| 848 | - | ||
| 849 | - | ||
| 850 | - | ||
| 780 | + |  | |
| 851 | 781 | ||
| 852 | 782 | Предпочтительная ширина по-прежнему равна 200, поэтому логического клиентская область теперь равна 200 и больше, чем видимая клиентская область. Нижняя кнопка имеет ширину 200, а на панели отображается горизонтальная полоса прокрутки. | |
| 853 | 783 | ||
| 854 | 784 | ## Позиция прокрутки | |
| 855 | 785 | ||
| 856 | 786 | Изменение положения полосы прокрутки не изменяет \[значения\] Left или Top любого дочернего элемента управления и не изменяет логическую клиентскую область, \[а также\] не влияет на автомасштабирование. Дочерние элементы управления лишь только виртуально перемещаются. | |
| 857 | 787 | ||
| 858 | 788 | ## Прокрутка и автомасштаб | |
| 859 | 789 | ||
| 860 | 790 | Когда AutoSize=true, LCL расширяет \[родительский\] элемент управления \[так\], чтобы разместить все его дочерние элементы управления, и никаких полос прокрутки не требуется. Если \[родительский\] элемент управления не может быть расширен, то (только) \[тогда проявляется\] вторичное действие AutoSize: перемещение дочерних элементов управления. | |
| 861 | 791 | ||
| 862 | 792 | # Пристыковка | |
| 863 | 793 | ||
| 864 | 794 | Пристыковка использует описанные методы и свойства этой страницы, см. [[Docking]]. | |
| 865 | 795 | ||
| 866 | 796 | # Splitter | |
| 867 | 797 | ||
| 868 | 798 | См. [[TSplitter/ru|TSplitter]]. | |
| 869 | 799 | ||
| 870 | 800 | # TLabel.WordWrap | |
| 871 | 801 | ||
| 872 | 802 | **TLabel.WordWrap**\[(перенос слов)\] изменяет поведение предпочтительного размера \[компонента\] label. **WordWrap=true** требует, чтобы \[величина\] Width \[компонента\] label была фиксированной, например, путем привязки левого и правого размера \[компонента\] label. Предпочтительная высота label затем вычисляется путем разбиения \[своства\] Caption на несколько строк. | |
| 873 | 803 | ||
| 874 | 804 | # Автоматическая настройка DPI и автоматическая настройка статической разметки | |
| 875 | 805 | ||
| 876 | 806 | Исторически LCL использовался в основном для создания статической разметки, несмотря на огромное количество опций, которые Lazarus предлагает для гибкой разметки макетов, таких как Align, Anchors и т.д., которые описаны в остальной части этой статьи. Кроме того, он также исторически игнорировал DPI целевого \[рабочего стола\] и вместо этого использовал значения в пикселях для измерения свойств слева, сверху, ширины и высоты элементов управления. Для настольных платформ и Windows CE это работает нормально, но с появлением поддержки LCL для Android это больше нельзя игнорировать. Начиная с Lazarus 0.9.31, LCL может пересчитывать статическую разметку LCL в пикселях \[на разметку\] в виде гибкой сетки. Существует выбор нескольких режимов, \[которые\] позволяют пересчитывать значения пикселей как в абсолютных \[величинах\], так и в корректируемых для DPI, или как считающихся просто частью размера формы. | |
| 877 | 807 | ||
| 878 | 808 | Важно отметить, что эти новые правила влияют только на элементы управления, которые расположены без выравнивания и только с большинством стандартных привязок. | |
| 879 | 809 | ||
| 880 | 810 | В случае, когда значения будут корректироваться для DPI, появляется новое свойство: TCustomForm.DesignTimeDPI, которое должно хранить значение DPI системы, в которой была создана форма. Значения позиционирования будут расширены, когда DPI целевого \[рабочего стола\] будет больше, чем время DPI времени разработки или уменьшено в противном случае. Обычное значение DPI для рабочего стола - 96, и это значение, заданное по умолчанию. | |
| 881 | 811 | ||
| 882 | 812 | `property DesignTimeDPI: Integer read FDesignTimeDPI write FDesignTimeDPI;` | |
| 883 | 813 | ||
| 884 | 814 | Способ настройки разметки можно контролировать с помощью свойства TApplication.LayoutAdjustmentPolicy | |
| 885 | 815 | ||
| 886 | 816 | ``` pascal | |
| 887 | 817 | TLayoutAdjustmentPolicy = ( | |
| 888 | 818 | lapDefault, // Зависимость от виджетсета | |
| 889 | 819 | lapFixedLayout, // Фиксированная абсолютная разметка на всех платформах | |
| 890 | 820 | lapAutoAdjustWithoutHorizontalScrolling, // Это используется платформой для смартфонов, | |
| 891 | 821 | // ось x растягивается, чтобы заполнить экран и | |
| 892 | 822 | // y масштабируется, чтобы соответствовать DPI | |
| 893 | 823 | lapAutoAdjustForDPI // Для рабочих столов с использованием High DPI, x и y масштабируются соответственно DPI | |
| 894 | 824 | ); | |
| 895 | 825 | ``` | |
| 896 | 826 | ||
| 897 | 827 | Следующие новые методы в TControl позволяют \[задать\] принудительную автонастройку разметки в конкретном контроле и во всех его дочерних элементах, или контролировать, как реагируют на это отдельные потомки TControl: | |
| 898 | 828 | ||
| 899 | 829 | ``` pascal | |
| 900 | 830 | TControl = class | |
| 901 | 831 | public | |
| 902 | 832 | ... | |
| 903 | 833 | procedure AutoAdjustLayout(AMode: TLayoutAdjustmentPolicy; | |
| 904 | 834 | const AFromDPI, AToDPI, AOldFormWidth, ANewFormWidth: Integer); virtual; | |
| 905 | 835 | function ShouldAutoAdjustLeftAndTop: Boolean; virtual; | |
| 906 | 836 | function ShouldAutoAdjustWidthAndHeight: Boolean; virtual; | |
| 907 | 837 | ``` | |
| 908 | 838 | ||
| 909 | 839 | LCL-CustomDrawn-Android будет вызывать AutoAdjustLayout, например, когда экран вращается.\ | |
| 910 | - | ||
| 911 | 840 | ||
| 912 | 841 | # Подробнее | |
| 913 | 842 | ||
| 914 | 843 | Многие элементы управления переопределяют *TControl.DoAutoSize* для выполнения фактического автомасштабирования. | |
| 915 | 844 | ||
| 916 | 845 | ВАЖНО: Многие элементы управления Delphi переопределяют этот метод, и многие вызывают этот метод напрямую после установки некоторых свойств. | |
| 917 | 846 | ||
| 918 | 847 | Во время создания дескриптора не все интерфейсы могут создавать полные Device Contexts\[(контексты устройств)\], которые необходимы для вычисления таких вещей, как размер текста. | |
| 919 | 848 | ||
| 920 | 849 | Вот почему вы всегда должны называть *AdjustSize* вместо `DoAutoSize`. | |
| 921 | 850 | ||
| 922 | 851 | `TControl.AdjustSize` вызывает `DoAutoSize` умным способом. | |
| 923 | 852 | ||
| 924 | 853 | Во время загрузки и создания дескриптора вызовы задерживаются. | |
| 925 | 854 | ||
| 926 | 855 | Этот метод изначально делает то же самое, что и *TWinControl.DoAutoSize*. Но поскольку `DoAutoSize` обычно переопределяется компонентами-потомками, нецелесообразно выполнять все проверки, которые могут привести к слишком большим издержкам. Чтобы уменьшить это, LCL вызывает `AdjustSize`. | |
| 927 | 856 | ||
| 928 | 857 | При установке AutoSize=true LCL автомасштабирует элемент управления по ширине и высоте. Это одна из самых сложных частей LCL, потому что результат зависит от почти сотен свойств. Начнем с простого: | |
| 929 | 858 | ||
| 930 | 859 | LCL будет только автомасштабировать *Width* (Height), если \[это свойство\] свободно для изменения величины. Другими словами - ширина не автомасштабируется, если: | |
| 931 | 860 | ||
| 932 | 861 | - левая и правая стороны привязаны. Вы можете привязать стороны с \[помощью\] свойства **Anchors** или установить свойство *Align* в alTop, alBottom или alClient. | |
| 933 | 862 | - \[параметр\] *Width* ограничен \[значением\] свойства *Constraints*. \[Свойство\] Constraints также может быть переопределено виджетсетом. Например, winapi не позволяет изменять размер выпадающего списка. Или gtk widgetset не позволяет изменять ширину вертикальной полосы прокрутки. | |
| 934 | 863 | ||
| 935 | 864 | То же \[справедливо и для свойства\] *Height*. | |
| 936 | 865 | ||
| 937 | 866 | Новый размер рассчитывается protected-методом **TControl.CalculatePreferredSize**. Этот метод запрашивает виджетсет для \[получения\] подходящих Width и Height. Например, TButton имеет предпочтительные ширину и высоту. TComboBox имеет только предпочтительную высоту. \[У него\] предпочтительная ширина возвращается как 0, и поэтому LCL не автомасштабирует ширину - \[LCL\] сохраняет ширину неизменной. Наконец, у TMemo нет предпочтительной ширины или высоты. Поэтому \[параметр\] AutoSize не влияет на TMemo. | |
| 938 | 867 | ||
| 939 | 868 | Некоторые элементы управления перекрывают этот метод. Например, потомки TGraphicControl, такие как TLabel, не имеют дескриптора окна и поэтому не могут запрашивать виджетсет. Они должны сами рассчитать их предпочтительную ширину и высоту. | |
| 940 | 869 | ||
| 941 | 870 | Виджетсеты должны переопределять метод GetPreferredSize для каждого класса виджетов, который имеет предпочтительный размер (ширина или высота, или оба). | |
| 942 | 871 | ||
| 943 | 872 | ## Parent.AutoSize | |
| 944 | 873 | ||
| 945 | 874 | Выше описанное \[дает\] простое объяснение. Реальный алгоритм \[функционально\] предусматривает гораздо больше возможностей и, следовательно, гораздо более сложен. | |
| 946 | 875 | ||
| 947 | 876 | ## Свойства / Методы | |
| 948 | 877 | ||
| 949 | 878 | - `Left` | |
| 950 | 879 | - `Top` | |
| 951 | 880 | ||
| 952 | 881 | Если Parent\<\>nil, то \[значения\] Left, Top - это расстояние в пикселях до верхнего левого пикселя клиентской области родителя (не прокручивается). Помните, что клиентская область - это всегда \[область\] *без* рамки и полосы прокрутки родителя. Для пользователей Delphi: некоторые элементы управления VCL, такие как TGroupbox, определяют клиентскую область как весь элемент управления, включая рамку, а некоторые нет - LCL же более последователен, поэтому Delphi \[с ним\] несовместим. Left и Top могут иметь отрицательные \[значения\] или \[быть\] больше, чем область клиента. Некоторые виджетсеты определяют минимум/максимум где-то около 10000\[px\] или более. | |
| 953 | 882 | ||
| 954 | 883 | Когда клиентская область прокручивается, Left и Top остаются неизменными. | |
| 955 | 884 | ||
| 956 | 885 | Во время изменения размера/перемещения \[элемента управления\] Left и Top не всегда синхронизируются с координатами дескриптора объекта. | |
| 957 | 886 | ||
| 958 | 887 | Если Parent=nil, тогда \[значения\] Left, Top зависят от виджетсета и диспетчера окон. До \[версии\] Lazarus 0.9.25 это обычно были координаты экрана верхне-левой части клиентской области формы. Это несовместимо с Delphi. Планируется изменить это \[поведение\] на Left, Top окна. | |
| 959 | 888 | ||
| 960 | 889 | Подсказка: Каждый раз, когда вы изменяете Left и Top, LCL мгновенно приходит в движение и перекомпонует весь макет. Если вы хотите изменить Left *и* Top, используйте взамен: | |
| 961 | 890 | ||
| 962 | 891 | ``` pascal | |
| 963 | 892 | with Button1 do | |
| 964 | 893 | SetBounds(NewLeft, NewTop, Width, Height); | |
| 965 | 894 | ``` | |
| 966 | 895 | ||
| 967 | - | ||
| 968 | - | ||
| 969 | 896 | - `Width` | |
| 970 | 897 | - `Height` | |
| 971 | 898 | ||
| 972 | 899 | Размер в пикселях не должен быть отрицательным, и большинство виджетсетов не допускают Width=0 и/или Height=0. Некоторые элементы управления на некоторых платформах определяют наибольшее минимальное ограничение в Constraints.MinInterfaceWidth/Height. Вместо того, чтобы изменять размер элемента управления в Width=0 и/или Height=0, установите Visible=false или Parent=nil. Во время изменения размера/перемещения \[свойства\] Width и Height не всегда синхронизируются с размером дескриптора объекта.\ | |
| 973 | 900 | ||
| 974 | 901 | - `BoundsRect` | |
| 975 | 902 | ||
| 976 | 903 | Аналогично `Bounds(Left, Top, Width, Height)`. | |
| 977 | 904 | ||
| 978 | 905 | Обычная ошибка новичка: | |
| 979 | 906 | ||
| 980 | 907 | ``` pascal | |
| 981 | 908 | BoundsRect.Left := 3; // НЕПРАВИЛЬНО: обычная ошибка новичка | |
| 982 | 909 | ``` | |
| 983 | 910 | ||
| 984 | - | ||
| 985 | 911 | Это не \[оказывает никакого\] влияния, потому что чтение BoundsRect является функцией. Она создает временный TRect в стеке. Вышеупомянутое те же, что и | |
| 986 | 912 | ||
| 987 | 913 | ``` pascal | |
| 988 | 914 | var | |
| 989 | 915 | r: TRect; | |
| 990 | 916 | begin | |
| 991 | 917 | r := BoundsRect; // получаем границы | |
| 992 | 918 | r.Left := 3; // изменяем значение в стеке | |
| 993 | 919 | end; // нет изменений | |
| 994 | 920 | ``` | |
| 995 | 921 | ||
| 996 | - | ||
| 997 | - | ||
| 998 | 922 | - `ClientRect` | |
| 999 | 923 | ||
| 1000 | 924 | Left и Top всегда равны 0,0. \[Свойства\] Width и Height - это видимый размер клиентской области в пикселях. Помните, что клиентская область - это \[то, что\] без рамки и без полос прокрутки. В прокручиваемой клиентской области логическая клиентская область может быть больше видимой.\ | |
| 1001 | 925 | ||
| 1002 | 926 | - `ClientOrigin` | |
| 1003 | 927 | ||
| 1004 | 928 | Возвращает экранную позицию верхне-левой координаты 0,0 клиентской области. Обратите внимание, что это значение является позицией, сохраненной в интерфейсе, и не всегда синхронизируется с LCL. Когда элемент управления перемещается, LCL устанавливает границы в нужную позицию и отправляет сообщение \[о\] перемещении в интерфейс. Интерфейс обрабатывает \[сообщения о\] перемещениях сразу или по очереди.\ | |
| 1005 | 929 | ||
| 1006 | 930 | - `LCLIntf.GetClientBounds` | |
| 1007 | 931 | ||
| 1008 | 932 | Возвращает клиентские границы элемента управления. Аналогичен ClientRect, но Left и Top - это расстояния в пикселах до левого и верхнего краев элемента управления. Например, в TGroupBox \[параметры\] Left, Top являются шириной и высотой левой и верхней границ рамки. Прокрутка не влияет на GetClientBounds.\ | |
| 1009 | 933 | ||
| 1010 | 934 | - `LCLIntf.GetWindowRect` | |
| 1011 | 935 | ||
| 1012 | 936 | После вызова \[этой функции\] ARect будет областью элемента управления в координатах экрана. Это означает, что Left и Top будут экранной координатой верхне-левого пикселя Дескриптора объекта, а \[значения\] Right и Bottom будут экранной координатой нижне-правого пиксела.\ | |
| 1013 | 937 | ||
| 1014 | 938 | - `FBaseBoundsLock: integer` | |
| 1015 | 939 | ||
| 1016 | 940 | Увеличивается/уменьшается \[методами\] LockBaseBounds/UnlockBaseBounds. Используется для сохранения \[поля\] FBaseBounds во время вызова SetBounds.\ | |
| 1017 | 941 | ||
| 1018 | 942 | - `FBaseParentClientSize: TPoint` | |
| 1019 | 943 | ||
| 1020 | 944 | Размер Parent.ClientRect действителен для FBaseBounds. \[Поля\] FBaseBounds и FBaseParentClientSize используются для вычисления расстояния для \[параметра выравнивания\] akRight (aBBottom). Когда размер родителя изменяется, LCL знает, какое расстояние сохранить.\ | |
| 1021 | 945 | ||
| 1022 | 946 | - `FBoundsRectForNewParent: TRect` | |
| 1023 | 947 | ||
| 1024 | 948 | При смене родителя элемента управления Дескриптор \[объекта\] создается \[заново\], и многое может случиться. Особенно этот процесс ненадежен для пристыкованных форм. Поэтому BoundsRect сохраняется. VCL использует аналогичные механизм.\ | |
| 1025 | 949 | ||
| 1026 | 950 | - `fLastAlignedBounds: TRect` | |
| 1027 | 951 | ||
| 1028 | 952 | Для получения пояснения см. `TControl.SetAlignedBounds`. Коротко: он останавливает некоторые циклы между интерфейсом и автомасштабированием в LCL.\ | |
| 1029 | 953 | ||
| 1030 | 954 | - `FLastChangebounds: TRect` | |
| 1031 | 955 | ||
| 1032 | 956 | Используется для остановки вызова ChangeBounds с одинаковыми координатами. Это случается очень часто.\ | |
| 1033 | 957 | ||
| 1034 | 958 | - `FLastDoChangeBounds: TRect` | |
| 1035 | 959 | ||
| 1036 | 960 | Используется, чтобы избежать вызова OnChangeBounds с теми же координатами. Это подавляет пользовательскую настройку автомасштабирования.\ | |
| 1037 | 961 | ||
| 1038 | 962 | - `FLastResizeClientHeight: integer` | |
| 1039 | 963 | - `FLastResizeClientWidth: integer` | |
| 1040 | 964 | - `FLastResizeHeight: integer` | |
| 1041 | 965 | - `FLastResizeWidth: integer` | |
| 1042 | 966 | ||
| 1043 | 967 | Используется, чтобы избежать вызова OnResize с теми же координатами. Это подавляет пользовательскую настройку автомасштабирования.\ | |
| 1044 | 968 | ||
| 1045 | 969 | - `FLoadedClientSize: TPoint` | |
| 1046 | 970 | ||
| 1047 | 971 | Во время загрузки многие вещи задерживаются, а многие вещи устанавливаются в неправильном порядке и ухудшаются. Вот почему сохраняется и вновь вызывается *SetClientWidth/SetClientHeight* в конце загрузки. Таким образом, LCL может восстанавливать размеры (напр., при *akRight*), используемые во время проектирование.\ | |
| 1048 | 972 | ||
| 1049 | 973 | - `FReadBounds: TRect` | |
| 1050 | 974 | ||
| 1051 | 975 | Аналогично `FLoadedClientSiz`, но для `SetLeft`, `SetTop`, `SetWidth`, `SetHeight`.\ | |
| 1052 | 976 | ||
| 1053 | 977 | - `procedure SetBoundsRectForNewParent(const AValue: TRect);` | |
| 1054 | 978 | ||
| 1055 | 979 | Используется для установки `FBoundsRectForNewParent`. См. выше.\ | |
| 1056 | 980 | ||
| 1057 | 981 | - `procedure SetAlignedBounds(aLeft, aTop, aWidth, aHeight: integer); virtual;` | |
| 1058 | 982 | ||
| 1059 | 983 | Как SetBounds, но без изменения размеров по умолчанию.\ | |
| 1060 | 984 | ||
| 1061 | - | ||
| 985 | + | - procedure SetInitialBounds(aLeft, aTop, aWidth, aHeight: integer); virtual;\<//tt\> | |
| 1062 | 986 | ||
| 1063 | 987 | "Умная" версия SetBounds, уменьшающая накладные расходы при создании и загрузке.\ | |
| 1064 | 988 | ||
| 1065 | 989 | - `procedure UpdateBaseBounds(StoreBounds, StoreParentClientSize, UseLoadedValues: boolean); virtual;` | |
| 1066 | 990 | ||
| 1067 | 991 | Фиксирует текущие границы базовых границ.\ | |
| 1068 | 992 | ||
| 1069 | 993 | - `procedure SetClientHeight(Value: Integer);` | |
| 1070 | 994 | - `procedure SetClientSize(Value: TPoint);` | |
| 1071 | 995 | - `procedure SetClientWidth(Value: Integer);` | |
| 1072 | 996 | ||
| 1073 | 997 | Существует также для совместимости с Delphi. Изменяет размер элемента управления, чтобы получить желаемый размер ClientRect.\ | |
| 1074 | 998 | ||
| 1075 | 999 | - `procedure ChangeBounds(ALeft, ATop, AWidth, AHeight: integer); virtual;` | |
| 1076 | 1000 | ||
| 1077 | 1001 | Это внутренний SetBounds. Применяет ограничения, обновляет базовые границы, вызывает OnChangeBound, OnResize, блокирует границы.\ | |
| 1078 | 1002 | ||
| 1079 | 1003 | - `procedure DoSetBounds(ALeft, ATop, AWidth, AHeight: integer); virtual;` | |
| 1080 | 1004 | ||
| 1081 | 1005 | Этот \[метод\] действительно устанавливает частные private-переменные FLeft, FTop, FWidth, FHeight.\ | |
| 1082 | 1006 | ||
| 1083 | 1007 | - `procedure SetBounds(aLeft, aTop, aWidth, aHeight: integer); virtual;` | |
| 1084 | 1008 | ||
| 1085 | 1009 | Это стандартная процедура, переопределяющая многие элементы управления Delphi. Также переопределяет TWinControl. | |
| 1086 | 1010 | ||
| 1087 | 1011 | - - игнорирует вызовы, когда границы заблокированы | |
| 1088 | 1012 | - блокирует FBoundsRealized, чтобы избежать накладных расходов на интерфейс во время автомасштабирования. ChangeBounds таким образом не блокируется.\ | |
| 1089 | 1013 | ||
| 1090 | 1014 | - `Function GetClientOrigin: TPoint; virtual;` | |
| 1091 | 1015 | ||
| 1092 | 1016 | Координаты экрана Left, Top клиентской области.\ | |
| 1093 | 1017 | ||
| 1094 | 1018 | - `Function GetClientRect: TRect; virtual;` | |
| 1095 | 1019 | ||
| 1096 | 1020 | Размер клиентской области. (всегда Left=0, Top=0)\ | |
| 1097 | 1021 | ||
| 1098 | 1022 | - `Function GetScrolledClientRect: TRect; virtual;` | |
| 1099 | 1023 | ||
| 1100 | 1024 | Видимая клиентская область ClientRect.\ | |
| 1101 | 1025 | ||
| 1102 | 1026 | - `function GetChildsRect(Scrolled: boolean): TRect; virtual;` | |
| 1103 | 1027 | ||
| 1104 | 1028 | Возвращает клиентский прямоугольник относительно Left, Top элемента управления. Если \[свойство\] Scrolled \[имеет значение\] true, прямоугольник перемещается текущими значениями прокрутки (например, см. TScrollingWincontrol).\ | |
| 1105 | 1029 | ||
| 1106 | 1030 | - `function GetClientScrollOffset: TPoint; virtual;` | |
| 1107 | 1031 | ||
| 1108 | 1032 | Возвращает смещение прокрутки клиентской области.\ | |
| 1109 | 1033 | ||
| 1110 | 1034 | - `function GetControlOrigin: TPoint; virtual;` | |
| 1111 | 1035 | ||
| 1112 | 1036 | Возвращает экранные координаты верхне-левой координаты 0,0 области элемента управления (верхне-левый пиксель элемента управления на экране). Обратите внимание, что это значение является позицией, сохраненной в интерфейсе, и не всегда синхронизируется с LCL. Когда элемент управления перемещается, LCL устанавливает границы в желаемую позицию и отправляет сообщение о перемещении в интерфейс. \[А уж\] интерфейс обрабатывает перемещаемый дескриптер сразу или в \[порядке\] очереди.\ | |
| 1113 | - | ||
| 1114 | 1037 | ||
| 1115 | 1038 | # ЧаВо | |
| 1116 | 1039 | ||
| 1117 | 1040 | ## Почему \[свойство\] AutoSize не работает в дизайнере должным образом? | |
| 1118 | 1041 | ||
| 1119 | 1042 | В дизайнере элементы управления можно перемещать, и свойства могут быть установлены практически в любом порядке. Чтобы разрешать это и избегать возможных конфликтов, \[свойство\] AutoSizing не обновляется при каждом изменении во время разработки. | |
| 1120 | 1043 | ||
| 1121 | 1044 | ## Почему TForm.AutoSize не работает, когда что-то меняется? | |
| 1122 | 1045 | ||
| 1123 | 1046 | См. [[Autosize / Layout/ru|Автомасштаб и формы]] | |
| 1124 | 1047 | ||
| 1125 | 1048 | ## Нужно ли мне вызывать Application.ProcessMessages при создании большого количества элементов управления? | |
| 1126 | 1049 | ||
| 1127 | 1050 | Application.ProcessMessages вызывается LCL автоматически после каждого сообщения (например, после каждого события, такого как OnClick). Вызов его сам по себе необходим только в том случае, если изменения должны немедленно стать видимыми пользователю. Например: | |
| 1128 | 1051 | ||
| 1129 | 1052 | ``` pascal | |
| 1130 | 1053 | procedure TFrom.Button1Click(Sender: TObject); | |
| 1131 | 1054 | begin | |
| 1132 | 1055 | // изменяем ширину элемента управления | |
| 1133 | 1056 | Button1.Width := Button1.Width + 10; | |
| 1134 | 1057 | // применяем все необходимые изменения и перерисовываем кнопку | |
| 1135 | 1058 | Application.ProcessMessages; | |
| 1136 | 1059 | // делаем много вещей, которые занимают много времени | |
| 1137 | 1060 | ... | |
| 1138 | 1061 | // после выхода из OnClick LCL автоматически обрабатывает сообщения | |
| 1139 | 1062 | end; | |
| 1140 | 1063 | ``` | |
| 1141 | 1064 | ||
| 1142 | 1065 | ## При включении привязки во время исполнения \[приложения\] элементы управления изменяют размеры, но не используют текущие значения. Почему? | |
| 1143 | 1066 | ||
| 1144 | 1067 | akBottom означает: сохранить расстояние до нижней части родителя. Зазоры для удержания определяются основными границами. Они устанавливаются в режиме разработки или во время исполнения вызовом \[методов\] SetBounds или UpdateBaseBounds. | |
| 1145 | 1068 | ||
| 1146 | 1069 | Например: TListBox (Anchors=\[akLeft,aTop\]) при проектировании имеет нижний зазор в 100 пикселей. И кнопку для включения/выключения \[значения\] akBottom TListBox'а. Теперь запустите приложение и нажмите кнопку, чтобы включить akBottom. 100-пиксельное расстояние будет активировано, потому что это был последний раз, когда программист определил базовые границы TListBox. Все остальные изменения были сделаны LCL и не имеют значения. Основные границы\[, заданные\] программистом определяют правила. Вы можете изменить размер формы, но 100 пикселей будет сохранено. Чтобы использовать текущие границы в качестве базовых, используйте: | |
| 1147 | 1070 | ||
| 1148 | 1071 | ``` pascal | |
| 1149 | 1072 | ListBox1.UpdateBaseBounds(true, true, false); | |
| 1150 | 1073 | ListBox1.Anchors := ListBox1.Anchors + [akBottom]; | |
| 1151 | 1074 | ``` | |
| 1152 | 1075 | ||
| 1153 | 1076 | Установка привязки не вызывает автоматически \[вызов метода\] UpdateBaseBounds, потому что это само по себе может уничтожить возможность изменения свойств. | |
| 1154 | 1077 | ||
| 1155 | 1078 | ## Изменение размера столбцов stringgrid в событии OnResize формы не работает | |
| 1156 | 1079 | ||
| 1157 | 1080 | \[Событие\] OnResize формы запускается, когда изменяются \[значения\] Width, Height, ClientWidth или ClientHeight формы. Это само по себе не зависит \[непосредственно\] от TStringGrid. Конечно, часто бывает, что и форма, и TStringGrid изменяют размеры. Это означает\[, что в таких случаях\] использование \[события\] OnResize формы часто будет работать, но не всегда. Ярким примером \[того, что использование OnResize формы\] всегда терпит неудачу, является \[случай\], когда тема изменена, и у вас есть TStringGrid\[, лежащий\] в TGroupBox на TForm. Когда тема меняется, размеры формы сохраняются, поэтому никакого \[события\] OnResize формы не запускается. Но меняется \[соответственно теме\] TGroupBox, поэтому TStringGrid должен быть изменен. | |
| 1158 | 1081 | ||
| 1159 | 1082 | Решение: используйте \[событие\] OnResize TStringGrid'а. | |
| 1160 | 1083 | ||
| 1161 | 1084 | ## Почему TForm.Width равен TForm.ClientWidth? | |
| 1162 | 1085 | ||
| 1163 | 1086 | Примечание Mattias'а: | |
| 1164 | 1087 | ||
| 1165 | 1088 | "Есть исторические и технические причины. | |
| 1166 | 1089 | ||
| 1167 | 1090 | Для форм без родителя Clientwidth равен Width, поскольку реальная ширина, включая рамку, не была доступна в Linux десять лет назад (по крайней мере, не достоверно для разных оконных менеджеров). Я не тестировал, но слышал, что теперь это возможно с gtk2. Основная проблема заключается в автомасштабировании, потому что для этого нужны размеры рамки до того, как форма будет отображена на экране. Возможно, \[размер рамки\] доступен только после \[наступления\] события, а это значит, что вам нужно подождать, что означает проблему для ShowModal. Изменив это, вы нарушите совместимость с большим количеством существующего кода [[LCL/ru]], но для этого мы добавили LCLVersion в файлы lfm. | |
| 1168 | 1091 | ||
| 1169 | 1092 | Существует новое определение компилятора **LCLRealFormBounds** в Lazarus trunk 1.7, которое позволяет использовать реальный размер для формы. Чтобы использовать его, просто скомпилируйте свое приложение с помощью `LCLRealFormBounds ON`. Пока что поддерживается только widgetset win32. | |
| 1170 | 1093 | ||
| 1171 | 1094 | Для всех остальных элементов управления применяются правила ClientWidth\<=Width. Width - это ClientWidth плюс рамка виджета. Вопрос в том, принадлежат ли полосы прокрутки рамке. Я бы сказал "да", и это было реализовано таким образом некоторое время назад. Видимо, это изменилось. См. Текущую проблему с курсором в synedit." | |
| 1172 | 1095 | ||
| 1173 | 1096 | ## Я получаю бесконечный цикл / Как отладить автомасштабирование? | |
| 1174 | 1097 | ||
| 1175 | 1098 | Вот некоторые примечания, что другие пользователи сделали неправильно и как найти выход: | |
| 1176 | 1099 | ||
| 1177 | 1100 | ### Отличия от Delphi | |
| 1178 | 1101 | ||
| 1179 | 1102 | Для пользователей Delphi: пожалуйста, прочитайте: [[Autosize / Layout/ru|Отличия от Delphi]] | |
| 1180 | 1103 | ||
| 1181 | 1104 | ### Переопределение метода [[LCL/ru|LCL]] и запуск пересчета | |
| 1182 | 1105 | ||
| 1183 | 1106 | Вы переопределяете метод и просите [[LCL/ru|LCL]] пересчитать снова, даже если ничего не изменилось. Проверьте настройки AdjustSize, Realign, AlignControls, InvalidatePreferredSize. Например: | |
| 1184 | 1107 | ||
| 1185 | 1108 | ``` pascal | |
| 1186 | 1109 | procedure TMainForm.SetBounds(ALeft, ATop, AWidth, AHeight: integer); | |
| 1187 | 1110 | begin | |
| 1188 | 1111 | // Это создаст бесконечный цикл | |
| 1189 | 1112 | InvalidatePreferredSize; | |
| 1190 | 1113 | ||
| 1191 | 1114 | // Это также создаст бесконечный цикл: | |
| 1192 | 1115 | OtherComponent.Left:=10; | |
| 1193 | 1116 | OtherComponent.Left:=20; | |
| 1194 | 1117 | ||
| 1195 | 1118 | inherited SetBounds(ALeft, ATop, AWidth, AHeight); | |
| 1196 | 1119 | end; | |
| 1197 | 1120 | ``` | |
| 1198 | 1121 | ||
| 1199 | 1122 | Объяснение: метод SetBounds вызывается часто, даже ничего не меняя. Например, так будет делать "Left:=30;". | |
| 1200 | 1123 | ||
| 1201 | 1124 | Решение: отслеживайте изменения: | |
| 1202 | 1125 | ||
| 1203 | 1126 | ``` pascal | |
| 1204 | 1127 | procedure TMainForm.SetBounds(ALeft, ATop, AWidth, AHeight: integer); | |
| 1205 | 1128 | begin | |
| 1206 | 1129 | if (Left <> ALeft) or (Top <> ATop) or (Width <> AWidth) or (Height <> AHeight) then | |
| 1207 | 1130 | InvalidatePreferredSize; | |
| 1208 | 1131 | inherited SetBounds(ALeft, ATop, AWidth, AHeight); | |
| 1209 | 1132 | end; | |
| 1210 | 1133 | ``` | |
| 1211 | 1134 | ||
| 1212 | 1135 | #### TWinControl.AlignControls | |
| 1213 | 1136 | ||
| 1214 | 1137 | ``` pascal | |
| 1215 | 1138 | procedure AlignControls(aControl: TControl; var aRect: TRect); override; | |
| 1216 | 1139 | ``` | |
| 1217 | 1140 | ||
| 1218 | 1141 | AlignControls перемещает и упорядочивает все дочерние элементы управления. Реализация [[LCL/ru|LCL]] игнорирует элементы управления с помощью Align=alCustom. | |
| 1219 | 1142 | ||
| 1220 | 1143 | Параметр `aControl: TControl` поддерживается для совместимости с VCL. [[LCL/ru|LCL]] всегда возвращает nil. Он дает приоритет aControl при применении свойства Align. Если у вас есть, например, два элемента управления A,B со \[значением\] Align=alLeft, то \[элемент управления, который будет\] нижним слева расположится левее \[другого\]. Если оба имеют одинаковые \[значения\] Left, \[то\] приоритетнее \[элемент в\] порядке создания. Теперь представьте, что вы хотите переключить оба элемента управления A, B в дизайнере. Вы перетащите B влево. Это приведет к установке \[значения\] B.Left в 0. Теперь AlignControls запускается и находит\[, что у обоих элементов управления значения\] A.Left=0 и B.Left=0. В обычном \[случае\] A \[по расположению окажется в\] приоритете. Чтобы \[приоритетнее оказался элемент управления\] B, VCL вызовет AlignControls(B,r). Таким образом, aControl является последним перемещенным. В отличие от VCL, [[LCL/ru|LCL]] позволяет комбинировать несколько изменений разметки без перерасчета на каждом шагу. [[LCL/ru|LCL]] отслеживает последние перемещенные элементы управления в TWinControl.fAlignControls и применяет порядок в TWinControl.CreateControlAlignList. Параметр aControl всегда равен nil. | |
| 1221 | 1144 | ||
| 1222 | 1145 | Смотри `TWinControl.CreateControlAlignList`.\ | |
| 1223 | 1146 | ||
| 1224 | 1147 | ### OnResize/OnChangeBounds конфликтует со свойствами LCL | |
| 1225 | 1148 | ||
| 1226 | 1149 | Вы устанавливаете границы, которые ущемляют свойства LCL. Например, по умолчанию TLabel.AutoSize \[имеет значение\] true. Если вы определяете Label1.Width в событии OnResize, LCL будет \[запускать\] пересчет, изменяя размер Label1, и снова вызывать OnResize. Запустите приложение в отладчике и воспроизведите ошибку. Когда оно войдет в \[бесконечный\] цикл, приостановите приложение и смотрите стек вызовов. Как вы видите, одно из ваших событий или ваших методов начинают искать там. Например: | |
| 1227 | 1150 | ||
| 1228 | 1151 | ``` pascal | |
| 1229 | 1152 | procedure TMainForm.FormResize(Sender: TObject); | |
| 1230 | 1153 | begin | |
| 1231 | 1154 | // если Button1 привязан или AutoSize=true, то следующее может создать бесконечный цикл: | |
| 1232 | 1155 | Button1.Width:=100; | |
| 1233 | 1156 | end; | |
| 1234 | 1157 | ``` | |
| 1235 | 1158 | ||
| 1236 | 1159 | ### Ошибка интерфейса LCL, пользовательский виджет | |
| 1237 | 1160 | ||
| 1238 | 1161 | Иногда интерфейс LCL или ваш пользовательский элемент управления имеет ошибку и отменяет границы LCL. Скомпилируйте LCL с \[опцией\] `-dVerboseIntfSizing`. Это запишет связь между LCL и интерфейсом LCL. Если виджет не допускает свободное изменение размера, он должен сказать \[об этом\] LCL через Constraints\[(ограничения)\]. Поищите `SetInterfaceConstraints` в различных интерфейсах LCL и `TWSControlClass.ConstraintWidth/Height`. | |
| 1239 | 1162 | ||
| 1240 | 1163 | ### alCustom | |
| 1241 | 1164 | ||
| 1242 | 1165 | Вы используете alCustom. В ранних версиях Lazarus это было реализовано только наполовину, но некоторые даровитые программисты использовали его для создания некоторых специальных эффектов. Теперь это реализовано, и ваша программа больше не работает. Пожалуйста, см. здесь, что alCustom делает: [[Autosize / Layout/ru|alCustom]]. | |
| 1243 | 1166 | ||
| 1244 | 1167 | # См. также | |
| 1245 | 1168 | ||
| 1246 | 1169 | - [[Docking]] | |
| 1247 | 1170 | - [[Anchor Sides/ru|Anchor Sides]] | |
| 1248 | 1171 | ||
| 1249 | 1172 | --- | |
| 1250 | 1173 | *From the Free Pascal wiki, page "Autosize / Layout/ru", as it stood on 2023-09-05 after a change by Zoltanleo, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).* |