1917 lines
72 KiB
ObjectPascal
1917 lines
72 KiB
ObjectPascal
{
|
|
Prog->DiskUtil - GUI disk utility application.
|
|
|
|
Provides a graphical interface for inspecting storage devices,
|
|
managing partitions, viewing volume information, and formatting
|
|
volumes with registered filesystems.
|
|
|
|
Layout: sidebar (device/volume list) + detail panel.
|
|
|
|
@author(Aaron Hance <[email protected]>)
|
|
}
|
|
unit app.diskutil;
|
|
|
|
interface
|
|
|
|
procedure init();
|
|
procedure UnitTest;
|
|
|
|
implementation
|
|
|
|
uses
|
|
driver.video.desktop,
|
|
driver.storage.fs.mgr,
|
|
memory.heap,
|
|
driver.video.lvgl,
|
|
driver.storage.vol.mbr,
|
|
proc.mgr,
|
|
proc.types,
|
|
driver.storage.mgr,
|
|
driver.storage.types,
|
|
core.strings,
|
|
io.syslog,
|
|
debug.tracer,
|
|
driver.video,
|
|
driver.storage.vol.mgr,
|
|
driver.video.windows,
|
|
core.util, arch.platform.cpu;
|
|
|
|
const
|
|
WIN_W = 740;
|
|
WIN_H = 480;
|
|
SIDEBAR_W = 210;
|
|
{ Selection modes }
|
|
SEL_NONE = 0;
|
|
SEL_DEVICE = 1;
|
|
SEL_VOLUME = 2;
|
|
|
|
var
|
|
win_id : uint32;
|
|
proc_pid : uint32;
|
|
sidebar : Plv_obj;
|
|
detail : Plv_obj;
|
|
{ Current selection }
|
|
sel_mode : uint32;
|
|
sel_dev_idx : uint32;
|
|
sel_vol_idx : uint32;
|
|
{ Partition slot for pending delete confirmation }
|
|
pending_del_slot : sint32;
|
|
{ Active msgbox (only one at a time) }
|
|
active_mbox : Plv_obj;
|
|
{ Widgets kept across dialogs }
|
|
fmt_dropdown : Plv_obj;
|
|
fmt_param_area : Plv_obj;
|
|
fmt_cluster_input : Plv_obj;
|
|
fmt_filecount_input: Plv_obj;
|
|
fmt_label_input : Plv_obj;
|
|
label_target_id, label_target_index : uint32;
|
|
fmt_param_error_lbl: Plv_obj;
|
|
add_textarea : Plv_obj;
|
|
add_err_lbl : Plv_obj;
|
|
{ Sidebar item tracking for highlight }
|
|
active_sidebar_btn : Plv_obj;
|
|
fmt_poll_timer : Plv_timer;
|
|
fmt_done_flag : uint32;
|
|
fmt_done_error : TError;
|
|
fmt_done_vol_idx : uint32;
|
|
storage_dirty_flag : uint32;
|
|
storage_watch_id : uint32;
|
|
ui_session_id : uint32;
|
|
operation_pending : boolean;
|
|
done_kind, done_device : uint32;
|
|
|
|
type
|
|
PFmtUICallbackCtx = ^TFmtUICallbackCtx;
|
|
TFmtUICallbackCtx = record
|
|
SessionID : uint32;
|
|
VolumeIdx : uint32;
|
|
Kind, DeviceIdx : uint32;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Forward declarations
|
|
============================================================ }
|
|
procedure launch; forward;
|
|
procedure diskutil_entry(ctx : PProcessContext); forward;
|
|
procedure onClose(wid: uint32); forward;
|
|
procedure refreshSidebar; forward;
|
|
procedure showDeviceDetail(devIdx: uint32); forward;
|
|
procedure showVolumeDetail(volIdx: uint32); forward;
|
|
procedure clearDetail; forward;
|
|
procedure fmt_poll_cb(tmr: Plv_timer); cdecl; forward;
|
|
procedure diskutil_storage_event(event : TStorageLifecycleEvent; device : PStorage_Device; volume : PStorage_Volume; error : TError; userdata : pointer); forward;
|
|
procedure rebuild_fmt_param_ui(fs : PFilesystem); forward;
|
|
|
|
{ ============================================================
|
|
Helpers — size formatting
|
|
============================================================ }
|
|
{ All transient text belongs to gfxd and is released on its next UI tick.
|
|
LVGL copies labels/options; no widget retains these pointers. A header in the
|
|
same allocation handles nested concatenations without leaking intermediates. }
|
|
type
|
|
PUIText = ^TUIText;
|
|
TUIText = record Next : PUIText; end;
|
|
var TextTemps : PUIText = nil;
|
|
|
|
procedure releaseTextTemps;
|
|
var item : PUIText;
|
|
begin
|
|
while TextTemps <> nil do begin
|
|
item := TextTemps; TextTemps := item^.Next; kfree(void(item));
|
|
end;
|
|
end;
|
|
|
|
function uiConcat(a, b : pchar) : pchar;
|
|
var item : PUIText; n, m : uint32; dest : pchar;
|
|
begin
|
|
uiConcat := '';
|
|
n := stringSize(a); m := stringSize(b);
|
|
item := PUIText(kalloc(sizeof(TUIText)+n+m+1));
|
|
if item = nil then exit;
|
|
item^.Next := TextTemps; TextTemps := item;
|
|
dest := pchar(PtrUInt(item)+sizeof(TUIText));
|
|
if n > 0 then memcpy(PtrUInt(a), PtrUInt(dest), n);
|
|
if m > 0 then memcpy(PtrUInt(b), PtrUInt(dest)+n, m);
|
|
dest[n+m] := #0; uiConcat := dest;
|
|
end;
|
|
|
|
function uiInt(value : uint64) : pchar;
|
|
var digits : array[0..20] of char; pos : uint32;
|
|
begin
|
|
pos := 20; digits[pos] := #0;
|
|
repeat
|
|
Dec(pos); digits[pos] := char(ord('0') + value mod 10); value := value div 10;
|
|
until value = 0;
|
|
uiInt := uiConcat(@digits[pos], '');
|
|
end;
|
|
|
|
procedure operation_done(error : TError; userdata : pointer); forward;
|
|
function begin_partition_ui(kind : uint32) : PFmtUICallbackCtx; forward;
|
|
|
|
function formatSizeStr(bytes: uint64): pchar;
|
|
begin
|
|
if bytes >= 1073741824 then
|
|
formatSizeStr := uiConcat(uiInt(bytes div 1073741824), ' GB')
|
|
else if bytes >= 1048576 then
|
|
formatSizeStr := uiConcat(uiInt(bytes div 1048576), ' MB')
|
|
else if bytes >= 1024 then
|
|
formatSizeStr := uiConcat(uiInt(bytes div 1024), ' KB')
|
|
else
|
|
formatSizeStr := uiConcat(uiInt(bytes), ' B');
|
|
end;
|
|
|
|
function formatSizePrecise(bytes: uint64): pchar;
|
|
var
|
|
whole, frac : uint64;
|
|
begin
|
|
if bytes >= 1073741824 then begin
|
|
whole := bytes div 1073741824;
|
|
frac := ((bytes mod 1073741824) * 10) div 1073741824;
|
|
if frac > 0 then
|
|
formatSizePrecise := uiConcat(uiConcat(uiInt(whole), uiConcat('.', uiInt(frac))), ' GB')
|
|
else
|
|
formatSizePrecise := uiConcat(uiInt(whole), ' GB');
|
|
end else if bytes >= 1048576 then begin
|
|
whole := bytes div 1048576;
|
|
frac := ((bytes mod 1048576) * 10) div 1048576;
|
|
if frac > 0 then
|
|
formatSizePrecise := uiConcat(uiConcat(uiInt(whole), uiConcat('.', uiInt(frac))), ' MB')
|
|
else
|
|
formatSizePrecise := uiConcat(uiInt(whole), ' MB');
|
|
end else if bytes >= 1024 then begin
|
|
whole := bytes div 1024;
|
|
formatSizePrecise := uiConcat(uiInt(whole), ' KB');
|
|
end else
|
|
formatSizePrecise := uiConcat(uiInt(bytes), ' B');
|
|
end;
|
|
|
|
function controllerStr(ct: TControllerType): pchar;
|
|
begin
|
|
controllerStr := driver.storage.mgr.controller_type_2_string(ct);
|
|
end;
|
|
|
|
function boolStr(b: boolean): pchar;
|
|
begin
|
|
if b then boolStr := 'Yes'
|
|
else boolStr := 'No';
|
|
end;
|
|
|
|
function formatErrorName(err : TError) : pchar;
|
|
begin
|
|
case err of
|
|
eNone: formatErrorName := 'eNone';
|
|
eUnknown: formatErrorName := 'eUnknown';
|
|
eNotSupported: formatErrorName := 'eNotSupported';
|
|
eOutOfMemory: formatErrorName := 'eOutOfMemory';
|
|
eInvalidArgument: formatErrorName := 'eInvalidArgument';
|
|
eFileInUse: formatErrorName := 'eFileInUse';
|
|
eFileDoesNotExist: formatErrorName := 'eFileDoesNotExist';
|
|
eInvalidFileName: formatErrorName := 'eInvalidFileName';
|
|
eInvalidFileExtension: formatErrorName := 'eInvalidFileExtension';
|
|
eFilenameTooLong: formatErrorName := 'eFilenameTooLong';
|
|
eDirectoryDoesNotExist: formatErrorName := 'eDirectoryDoesNotExist';
|
|
eDirectoryAlreadyExists: formatErrorName := 'eDirectoryAlreadyExists';
|
|
eDirectoryNotEmpty: formatErrorName := 'eDirectoryNotEmpty';
|
|
eDirectoryFull: formatErrorName := 'eDirectoryFull';
|
|
eNotADirectory: formatErrorName := 'eNotADirectory';
|
|
eWriteOnly: formatErrorName := 'eWriteOnly';
|
|
eReadOnly: formatErrorName := 'eReadOnly';
|
|
ePermissionDenied: formatErrorName := 'ePermissionDenied';
|
|
eInvalidPath: formatErrorName := 'eInvalidPath';
|
|
eTooManyOpenFiles: formatErrorName := 'eTooManyOpenFiles';
|
|
eInvalidHandle: formatErrorName := 'eInvalidHandle';
|
|
eFileNotLoaded: formatErrorName := 'eFileNotLoaded';
|
|
eAlreadyExists: formatErrorName := 'eAlreadyExists';
|
|
eDiskFull: formatErrorName := 'eDiskFull';
|
|
eIOError: formatErrorName := 'eIOError';
|
|
eIOTimeout: formatErrorName := 'eIOTimeout';
|
|
eIOCancelled: formatErrorName := 'eIOCancelled';
|
|
eDeviceNotReady: formatErrorName := 'eDeviceNotReady';
|
|
eCorruptFilesystem: formatErrorName := 'eCorruptFilesystem';
|
|
eBadSector: formatErrorName := 'eBadSector';
|
|
eAlreadyMounted: formatErrorName := 'eAlreadyMounted';
|
|
eNotMounted: formatErrorName := 'eNotMounted';
|
|
eUnsupportedFilesystem: formatErrorName := 'eUnsupportedFilesystem';
|
|
eDeviceNotFound: formatErrorName := 'eDeviceNotFound';
|
|
eDeviceRemoved: formatErrorName := 'eDeviceRemoved';
|
|
eQueueFull: formatErrorName := 'eQueueFull';
|
|
eNoFreeSlot: formatErrorName := 'eNoFreeSlot';
|
|
eInvalidPartitionTable: formatErrorName := 'eInvalidPartitionTable';
|
|
eVolumeNotFound: formatErrorName := 'eVolumeNotFound';
|
|
else
|
|
formatErrorName := 'eUnknown';
|
|
end;
|
|
end;
|
|
|
|
{ Check if a pchar string contains only digits }
|
|
function isNumericStr(s: pchar): boolean;
|
|
var
|
|
i, len : uint32;
|
|
begin
|
|
isNumericStr := false;
|
|
if s = nil then exit;
|
|
len := stringSize(s);
|
|
if len = 0 then exit;
|
|
for i := 0 to len - 1 do begin
|
|
if (s[i] < '0') or (s[i] > '9') then exit;
|
|
end;
|
|
isNumericStr := true;
|
|
end;
|
|
|
|
{ ============================================================
|
|
GUI helpers
|
|
============================================================ }
|
|
procedure addInfoRow(parent: Plv_obj; row_w: sint32; key: pchar; value: pchar);
|
|
var
|
|
row, lbl_key, lbl_val : Plv_obj;
|
|
begin
|
|
row := lv_obj_create(parent);
|
|
lv_obj_remove_style_all(row);
|
|
lv_obj_set_size(row, row_w - 24, 24);
|
|
lv_obj_set_style_pad_all(row, 0, 0);
|
|
lv_obj_remove_flag(row, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_style_layout(row, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(row, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
lbl_key := lv_label_create(row);
|
|
lv_label_set_text(lbl_key, key);
|
|
lv_obj_set_style_text_color(lbl_key, lv_color_make(140, 150, 170), 0);
|
|
lv_obj_set_style_text_font(lbl_key, @lv_font_montserrat_14, 0);
|
|
|
|
lbl_val := lv_label_create(row);
|
|
lv_label_set_text(lbl_val, value);
|
|
lv_obj_set_style_text_color(lbl_val, lv_color_make(220, 225, 240), 0);
|
|
lv_obj_set_style_text_font(lbl_val, @lv_font_montserrat_14, 0);
|
|
end;
|
|
|
|
procedure addSectionHeader(parent: Plv_obj; title: pchar);
|
|
var
|
|
lbl : Plv_obj;
|
|
begin
|
|
lbl := lv_label_create(parent);
|
|
lv_label_set_text(lbl, title);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(100, 160, 255), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
|
|
procedure addSeparator(parent: Plv_obj; row_w: sint32);
|
|
var
|
|
sep : Plv_obj;
|
|
begin
|
|
sep := lv_obj_create(parent);
|
|
lv_obj_remove_style_all(sep);
|
|
lv_obj_set_size(sep, row_w - 24, 1);
|
|
lv_obj_set_style_bg_color(sep, lv_color_make(55, 60, 78), 0);
|
|
lv_obj_set_style_bg_opa(sep, LV_OPA_COVER, 0);
|
|
lv_obj_remove_flag(sep, LV_OBJ_FLAG_SCROLLABLE);
|
|
end;
|
|
|
|
procedure addStatusLabel(parent: Plv_obj; text: pchar; r, g, b: uint8);
|
|
var
|
|
lbl : Plv_obj;
|
|
begin
|
|
lbl := lv_label_create(parent);
|
|
lv_label_set_text(lbl, text);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(r, g, b), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
|
|
function makeButton(parent: Plv_obj; text: pchar; w: sint32): Plv_obj;
|
|
var
|
|
btn, lbl : Plv_obj;
|
|
begin
|
|
btn := lv_button_create(parent);
|
|
lv_obj_remove_style_all(btn);
|
|
lv_obj_set_size(btn, w, 30);
|
|
lv_obj_set_style_bg_color(btn, lv_color_make(55, 90, 190), 0);
|
|
lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_radius(btn, 6, 0);
|
|
lv_obj_add_flag(btn, LV_OBJ_FLAG_CLICKABLE);
|
|
lv_obj_set_style_layout(btn, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(btn, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(btn, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
lbl := lv_label_create(btn);
|
|
lv_label_set_text(lbl, text);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(225, 230, 245), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
|
|
makeButton := btn;
|
|
end;
|
|
|
|
function makeDangerButton(parent: Plv_obj; text: pchar; w: sint32): Plv_obj;
|
|
var
|
|
btn, lbl : Plv_obj;
|
|
begin
|
|
btn := lv_button_create(parent);
|
|
lv_obj_remove_style_all(btn);
|
|
lv_obj_set_size(btn, w, 26);
|
|
lv_obj_set_style_bg_color(btn, lv_color_make(160, 50, 50), 0);
|
|
lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_radius(btn, 4, 0);
|
|
lv_obj_add_flag(btn, LV_OBJ_FLAG_CLICKABLE);
|
|
lv_obj_set_style_layout(btn, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(btn, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(btn, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
lbl := lv_label_create(btn);
|
|
lv_label_set_text(lbl, text);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(240, 220, 220), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
|
|
makeDangerButton := btn;
|
|
end;
|
|
|
|
{ Add a usage bar (colored bar showing used vs total) }
|
|
procedure addUsageBar(parent: Plv_obj; row_w: sint32; used, total: uint64);
|
|
var
|
|
bar : Plv_obj;
|
|
pct : sint32;
|
|
begin
|
|
if total = 0 then pct := 0
|
|
else pct := sint32((used * 100) div total);
|
|
if pct > 100 then pct := 100;
|
|
|
|
bar := lv_bar_create(parent);
|
|
lv_obj_set_size(bar, row_w - 24, 14);
|
|
lv_bar_set_range(bar, 0, 100);
|
|
lv_bar_set_value(bar, pct, LV_ANIM_OFF);
|
|
|
|
{ Track background }
|
|
lv_obj_set_style_bg_color(bar, lv_color_make(45, 48, 60), LV_PART_MAIN);
|
|
lv_obj_set_style_bg_opa(bar, LV_OPA_COVER, LV_PART_MAIN);
|
|
lv_obj_set_style_radius(bar, 4, LV_PART_MAIN);
|
|
|
|
{ Fill indicator }
|
|
if pct < 75 then
|
|
lv_obj_set_style_bg_color(bar, lv_color_make(70, 160, 100), LV_PART_INDICATOR)
|
|
else if pct < 90 then
|
|
lv_obj_set_style_bg_color(bar, lv_color_make(200, 170, 50), LV_PART_INDICATOR)
|
|
else
|
|
lv_obj_set_style_bg_color(bar, lv_color_make(200, 60, 60), LV_PART_INDICATOR);
|
|
lv_obj_set_style_bg_opa(bar, LV_OPA_COVER, LV_PART_INDICATOR);
|
|
lv_obj_set_style_radius(bar, 4, LV_PART_INDICATOR);
|
|
end;
|
|
|
|
{ ============================================================
|
|
Size parser — accepts '500MB', '2GB', '1024KB', '4096B',
|
|
or plain number (bytes). Returns sector count.
|
|
Returns 0 on invalid input.
|
|
============================================================ }
|
|
function parseSize(s: pchar; sectorSize: uint32): uint32;
|
|
var i, digit : uint32; value, limit, multiplier, bytes : uint64;
|
|
begin
|
|
parseSize := 0;
|
|
if (s = nil) or (sectorSize = 0) then exit;
|
|
limit := uint64($FFFFFFFF) * sectorSize;
|
|
i := 0; value := 0;
|
|
while (s[i] >= '0') and (s[i] <= '9') do begin
|
|
digit := ord(s[i])-ord('0');
|
|
if value > (limit-digit) div 10 then exit;
|
|
value := value*10+digit; Inc(i);
|
|
end;
|
|
if (i = 0) or (value = 0) then exit;
|
|
multiplier := 1;
|
|
case s[i] of
|
|
'K','k': begin multiplier := 1024; Inc(i); end;
|
|
'M','m': begin multiplier := 1048576; Inc(i); end;
|
|
'G','g': begin multiplier := 1073741824; Inc(i); end;
|
|
end;
|
|
if (s[i] = 'B') or (s[i] = 'b') then Inc(i);
|
|
if s[i] <> #0 then exit;
|
|
if value > limit div multiplier then exit;
|
|
bytes := value*multiplier;
|
|
if (bytes mod sectorSize) <> 0 then exit;
|
|
parseSize := uint32(bytes div sectorSize);
|
|
end;
|
|
|
|
procedure closeMsgBox;
|
|
begin
|
|
if active_mbox <> nil then begin
|
|
lv_msgbox_close(active_mbox);
|
|
active_mbox := nil;
|
|
end;
|
|
add_textarea := nil;
|
|
add_err_lbl := nil;
|
|
fmt_dropdown := nil;
|
|
fmt_param_area := nil;
|
|
fmt_cluster_input := nil;
|
|
fmt_filecount_input := nil;
|
|
fmt_label_input := nil;
|
|
fmt_param_error_lbl := nil;
|
|
end;
|
|
|
|
procedure set_fmt_param_error(text : pchar);
|
|
begin
|
|
if fmt_param_area = nil then exit;
|
|
if fmt_param_error_lbl = nil then begin
|
|
fmt_param_error_lbl := lv_label_create(fmt_param_area);
|
|
lv_obj_set_style_text_color(fmt_param_error_lbl, lv_color_make(230, 80, 80), 0);
|
|
lv_obj_set_style_text_font(fmt_param_error_lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
lv_label_set_text(fmt_param_error_lbl, text);
|
|
end;
|
|
|
|
procedure rebuild_fmt_param_ui(fs : PFilesystem);
|
|
var
|
|
lbl : Plv_obj;
|
|
begin
|
|
if fmt_param_area = nil then exit;
|
|
fmt_cluster_input := nil;
|
|
fmt_filecount_input := nil;
|
|
fmt_label_input := nil;
|
|
fmt_param_error_lbl := nil;
|
|
lv_obj_clean(fmt_param_area);
|
|
|
|
if fs = nil then exit;
|
|
if fs^.formatParamFlags = 0 then begin
|
|
addStatusLabel(fmt_param_area, 'No filesystem-specific format options.', 140, 150, 170);
|
|
exit;
|
|
end;
|
|
|
|
if (fs^.formatParamFlags and FS_FORMAT_PARAM_CLUSTER_SIZE) <> 0 then begin
|
|
lbl := lv_label_create(fmt_param_area);
|
|
lv_label_set_text(lbl, 'Sectors per cluster (blank = auto, power of 2)');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(180, 190, 210), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
fmt_cluster_input := lv_textarea_create(fmt_param_area);
|
|
lv_textarea_set_one_line(fmt_cluster_input, true);
|
|
lv_textarea_set_placeholder_text(fmt_cluster_input, 'Auto');
|
|
lv_obj_set_width(fmt_cluster_input, 220);
|
|
end;
|
|
|
|
if (fs^.formatParamFlags and FS_FORMAT_PARAM_FILE_COUNT) <> 0 then begin
|
|
lbl := lv_label_create(fmt_param_area);
|
|
lv_label_set_text(lbl, 'Directory/file table entry count');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(180, 190, 210), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
fmt_filecount_input := lv_textarea_create(fmt_param_area);
|
|
lv_textarea_set_one_line(fmt_filecount_input, true);
|
|
lv_textarea_set_placeholder_text(fmt_filecount_input, '1000');
|
|
lv_obj_set_width(fmt_filecount_input, 220);
|
|
end;
|
|
if (fs^.formatParamFlags and FS_FORMAT_PARAM_LABEL) <> 0 then begin
|
|
lbl := lv_label_create(fmt_param_area);
|
|
lv_label_set_text(lbl, 'Volume label (up to 11 ASCII characters)');
|
|
fmt_label_input := lv_textarea_create(fmt_param_area);
|
|
lv_textarea_set_one_line(fmt_label_input,true);
|
|
lv_textarea_set_max_length(fmt_label_input,11);
|
|
lv_textarea_set_placeholder_text(fmt_label_input,'Optional');
|
|
lv_obj_set_width(fmt_label_input,260);
|
|
end;
|
|
end;
|
|
|
|
procedure fmt_fs_change_cb(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
selIdx : uint32;
|
|
fs : PFilesystem;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_VALUE_CHANGED then exit;
|
|
selIdx := lv_dropdown_get_selected(fmt_dropdown);
|
|
fs := driver.storage.fs.mgr.get_filesystem(selIdx);
|
|
rebuild_fmt_param_ui(fs);
|
|
end;
|
|
|
|
{ ============================================================
|
|
Dialog callbacks — Add Partition
|
|
============================================================ }
|
|
procedure add_part_ok_cb(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
device : PStorage_Device;
|
|
text : pchar;
|
|
sectors : uint32;
|
|
freeSec : uint32;
|
|
slot : sint32;
|
|
lba : uint32;
|
|
part : TPartition_table;
|
|
mbr_rec : PMaster_Boot_Record;
|
|
needsInit : boolean;
|
|
cbCtx : PFmtUICallbackCtx;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
|
|
device := driver.storage.mgr.get_device(sel_dev_idx);
|
|
if device = nil then begin closeMsgBox; exit; end;
|
|
|
|
{ Check cached mbr to decide if disk needs initialisation }
|
|
mbr_rec := driver.storage.mgr.get_cached_mbr(device);
|
|
needsInit := (mbr_rec = nil) or (mbr_rec^.boot_sector <> $AA55);
|
|
|
|
if needsInit then
|
|
freeSec := device^.maxSectorCount - 1
|
|
else
|
|
freeSec := driver.storage.vol.mgr.get_free_sector_count(device);
|
|
|
|
text := lv_textarea_get_text(add_textarea);
|
|
sectors := 0;
|
|
|
|
{ Parse size if provided }
|
|
if (text <> nil) and (text^ <> #0) then begin
|
|
sectors := parseSize(text, device^.sectorSize);
|
|
if sectors = 0 then begin
|
|
if add_err_lbl <> nil then
|
|
lv_label_set_text(add_err_lbl, 'Invalid size. Use e.g. 100MB, 2GB, 512KB.')
|
|
else begin
|
|
add_err_lbl := lv_label_create(lv_msgbox_get_content(active_mbox));
|
|
lv_label_set_text(add_err_lbl, 'Invalid size. Use e.g. 100MB, 2GB, 512KB.');
|
|
lv_obj_set_style_text_color(add_err_lbl, lv_color_make(230, 80, 80), 0);
|
|
lv_obj_set_style_text_font(add_err_lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
exit;
|
|
end;
|
|
if sectors > freeSec then begin
|
|
if add_err_lbl <> nil then
|
|
lv_label_set_text(add_err_lbl, 'Requested size exceeds available free space.')
|
|
else begin
|
|
add_err_lbl := lv_label_create(lv_msgbox_get_content(active_mbox));
|
|
lv_label_set_text(add_err_lbl, 'Requested size exceeds available free space.');
|
|
lv_obj_set_style_text_color(add_err_lbl, lv_color_make(230, 80, 80), 0);
|
|
lv_obj_set_style_text_font(add_err_lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
exit;
|
|
end;
|
|
end;
|
|
|
|
{ If blank, use all free space }
|
|
if sectors = 0 then
|
|
sectors := freeSec;
|
|
|
|
if sectors = 0 then begin closeMsgBox; exit; end;
|
|
|
|
{ If disk needs init, do it now (async write, but cache updated synchronously) }
|
|
if needsInit then begin
|
|
{ Blank MBR and first partition are committed in one worker write. }
|
|
slot := 0;
|
|
lba := 1;
|
|
end else begin
|
|
slot := driver.storage.vol.mgr.find_free_slot(device);
|
|
if slot < 0 then begin closeMsgBox; exit; end;
|
|
|
|
lba := driver.storage.vol.mgr.find_free_space(device, sectors);
|
|
if lba = 0 then begin
|
|
if add_err_lbl <> nil then
|
|
lv_label_set_text(add_err_lbl, 'Could not find contiguous free space.')
|
|
else begin
|
|
add_err_lbl := lv_label_create(lv_msgbox_get_content(active_mbox));
|
|
lv_label_set_text(add_err_lbl, 'Could not find contiguous free space.');
|
|
lv_obj_set_style_text_color(add_err_lbl, lv_color_make(230, 80, 80), 0);
|
|
lv_obj_set_style_text_font(add_err_lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
exit;
|
|
end;
|
|
end;
|
|
|
|
memset(PtrUInt(@part), 0, sizeof(TPartition_table));
|
|
driver.storage.vol.mbr.setup_partition(@part, lba, sectors);
|
|
cbCtx := begin_partition_ui(1);
|
|
if cbCtx = nil then exit;
|
|
driver.storage.vol.mgr.add_partition_async(device, uint32(slot), part, @operation_done, cbCtx);
|
|
end;
|
|
|
|
procedure add_part_cancel_cb(e: Plv_event); cdecl;
|
|
var code : uint32;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
closeMsgBox;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Dialog callbacks — Delete Partition
|
|
============================================================ }
|
|
procedure del_part_ok_cb(e: Plv_event); cdecl;
|
|
var device : PStorage_Device; cbCtx : PFmtUICallbackCtx; slot : uint32;
|
|
begin
|
|
if lv_event_get_code(e) <> LV_EVENT_CLICKED then exit;
|
|
if operation_pending then exit;
|
|
device := driver.storage.mgr.get_device(sel_dev_idx);
|
|
if (device = nil) or (pending_del_slot < 0) or (pending_del_slot > 3) then exit;
|
|
slot := uint32(pending_del_slot);
|
|
cbCtx := begin_partition_ui(2);
|
|
if cbCtx = nil then exit;
|
|
driver.storage.vol.mgr.remove_partition_async(device, slot, @operation_done, cbCtx);
|
|
end;
|
|
|
|
procedure del_part_cancel_cb(e: Plv_event); cdecl;
|
|
var code : uint32;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
closeMsgBox;
|
|
end;
|
|
|
|
{ Per-row delete button click — opens confirmation for that specific slot }
|
|
procedure row_del_click_cb(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
slot : uint32;
|
|
mbox : Plv_obj;
|
|
btn_ok : Plv_obj;
|
|
btn_no : Plv_obj;
|
|
txt : pchar;
|
|
device : PStorage_Device;
|
|
mbr_rec : PMaster_Boot_Record;
|
|
part : TPartition_table;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
|
|
slot := uint32(lv_event_get_user_data(e));
|
|
pending_del_slot := sint32(slot);
|
|
|
|
txt := uiConcat('Delete partition in slot ', uiInt(slot));
|
|
|
|
device := driver.storage.mgr.get_device(sel_dev_idx);
|
|
if device <> nil then begin
|
|
mbr_rec := driver.storage.mgr.get_cached_mbr(device);
|
|
if mbr_rec <> nil then begin
|
|
part := mbr_rec^.partition[slot];
|
|
if part.sector_count > 0 then begin
|
|
txt := uiConcat(txt, ' (');
|
|
txt := uiConcat(txt, formatSizeStr(uint64(part.sector_count) * device^.sectorSize));
|
|
txt := uiConcat(txt, ')');
|
|
end;
|
|
end;
|
|
end;
|
|
txt := uiConcat(txt, '?');
|
|
|
|
closeMsgBox;
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Delete Partition');
|
|
lv_msgbox_add_text(mbox, txt);
|
|
addStatusLabel(lv_msgbox_get_content(mbox), 'This action cannot be undone.', 230, 160, 80);
|
|
|
|
btn_ok := lv_msgbox_add_footer_button(mbox, 'Delete');
|
|
lv_obj_add_event_cb(btn_ok, @del_part_ok_cb, LV_EVENT_CLICKED, nil);
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'Cancel');
|
|
lv_obj_add_event_cb(btn_no, @del_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
end;
|
|
|
|
{ ============================================================
|
|
Dialog callbacks — Format Volume
|
|
============================================================ }
|
|
|
|
{ Async completion callback — fired from ISR context when format finishes.
|
|
Only sets completion flags; LVGL work happens later on the UI poll timer. }
|
|
procedure operation_done(error : TError; userdata : pointer);
|
|
var
|
|
ctx : PFmtUICallbackCtx;
|
|
flags : PtrUInt;
|
|
begin
|
|
ctx := PFmtUICallbackCtx(userdata);
|
|
if ctx <> nil then begin
|
|
flags := arch.platform.cpu.lock;
|
|
if ctx^.SessionID = ui_session_id then begin
|
|
fmt_done_error := error;
|
|
fmt_done_vol_idx := ctx^.VolumeIdx;
|
|
done_kind := ctx^.Kind;
|
|
done_device := ctx^.DeviceIdx;
|
|
puint32(@fmt_done_flag)^ := 1;
|
|
end;
|
|
arch.platform.cpu.unlock(flags);
|
|
kfree(void(ctx));
|
|
end;
|
|
end;
|
|
|
|
procedure diskutil_storage_event(event : TStorageLifecycleEvent; device : PStorage_Device; volume : PStorage_Volume; error : TError; userdata : pointer);
|
|
begin
|
|
puint32(@storage_dirty_flag)^ := 1;
|
|
end;
|
|
|
|
procedure fmt_poll_cb(tmr: Plv_timer); cdecl;
|
|
var
|
|
mbox : Plv_obj;
|
|
begin
|
|
releaseTextTemps;
|
|
if puint32(@storage_dirty_flag)^ <> 0 then begin
|
|
puint32(@storage_dirty_flag)^ := 0;
|
|
refreshSidebar;
|
|
if sel_mode = SEL_VOLUME then begin
|
|
if driver.storage.vol.mgr.get_volume(sel_vol_idx) <> nil then
|
|
showVolumeDetail(sel_vol_idx)
|
|
else
|
|
clearDetail;
|
|
end else if sel_mode = SEL_DEVICE then begin
|
|
if driver.storage.mgr.get_device(sel_dev_idx) <> nil then
|
|
showDeviceDetail(sel_dev_idx)
|
|
else
|
|
clearDetail;
|
|
end;
|
|
end;
|
|
|
|
if puint32(@fmt_done_flag)^ <> 1 then exit;
|
|
puint32(@fmt_done_flag)^ := 0;
|
|
|
|
closeMsgBox;
|
|
refreshSidebar;
|
|
operation_pending := false;
|
|
if done_kind = 0 then showVolumeDetail(fmt_done_vol_idx)
|
|
else showDeviceDetail(done_device);
|
|
|
|
if fmt_done_error <> eNone then begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Storage Operation Failed');
|
|
lv_msgbox_add_text(mbox, 'The operation did not complete. Check the error before retrying.');
|
|
lv_msgbox_add_text(mbox, formatErrorName(fmt_done_error));
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(mbox, 'OK'), @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
end else begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Storage Operation Complete');
|
|
lv_msgbox_add_text(mbox, 'The requested changes have been written successfully.');
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(mbox, 'OK'), @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
end;
|
|
end;
|
|
|
|
function begin_partition_ui(kind : uint32) : PFmtUICallbackCtx;
|
|
var ctx : PFmtUICallbackCtx;
|
|
begin
|
|
begin_partition_ui := nil;
|
|
if operation_pending then exit;
|
|
ctx := PFmtUICallbackCtx(kalloc(sizeof(TFmtUICallbackCtx)));
|
|
if ctx = nil then begin
|
|
closeMsgBox;
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox, 'Out of memory');
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(active_mbox, 'OK'), @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
ctx^.SessionID := ui_session_id; ctx^.VolumeIdx := sel_vol_idx;
|
|
ctx^.Kind := kind; ctx^.DeviceIdx := sel_dev_idx;
|
|
closeMsgBox;
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox, 'Updating partition table');
|
|
lv_msgbox_add_text(active_mbox, 'The operation is running in the background.');
|
|
operation_pending := true;
|
|
begin_partition_ui := ctx;
|
|
end;
|
|
|
|
procedure fmt_ok_cb(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
selIdx : uint32;
|
|
fs : PFilesystem;
|
|
vol : PStorage_Volume;
|
|
cbCtx : PFmtUICallbackCtx;
|
|
params : TFSFormatParams;
|
|
paramPtr : PFSFormatParams;
|
|
text : pchar;
|
|
value : uint32;
|
|
normalized : TVolumeLabel;
|
|
begin
|
|
if operation_pending then exit;
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
|
|
vol := driver.storage.vol.mgr.get_volume(sel_vol_idx);
|
|
if vol = nil then begin closeMsgBox; exit; end;
|
|
if driver.storage.vol.mgr.volume_is_busy(vol) then begin
|
|
closeMsgBox;
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox, 'Format Busy');
|
|
lv_msgbox_add_text(active_mbox, 'This volume is busy. Wait for the current operation to finish.');
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(active_mbox, 'OK'), @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
|
|
selIdx := lv_dropdown_get_selected(fmt_dropdown);
|
|
fs := driver.storage.fs.mgr.get_filesystem(selIdx);
|
|
if fs = nil then begin closeMsgBox; exit; end;
|
|
|
|
memset(PtrUInt(@params), 0, sizeof(TFSFormatParams));
|
|
params.Version := FS_FORMAT_PARAMS_VERSION_1;
|
|
paramPtr := nil;
|
|
|
|
if (fs^.formatParamFlags and FS_FORMAT_PARAM_CLUSTER_SIZE) <> 0 then begin
|
|
if fmt_cluster_input <> nil then begin
|
|
text := lv_textarea_get_text(fmt_cluster_input);
|
|
if (text <> nil) and (text^ <> #0) then begin
|
|
if (stringSize(text) > 5) or (not isNumericStr(text)) then begin
|
|
set_fmt_param_error('Cluster size must be a number.');
|
|
exit;
|
|
end;
|
|
value := stringToInt(text);
|
|
if (value = 0) or (value > 128) or ((value and (value - 1)) <> 0) then begin
|
|
set_fmt_param_error('Cluster size must be a power of two from 1 to 128.');
|
|
exit;
|
|
end;
|
|
params.Flags := params.Flags or FS_FORMAT_PARAM_CLUSTER_SIZE;
|
|
params.ClusterSize := value;
|
|
paramPtr := @params;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if (fs^.formatParamFlags and FS_FORMAT_PARAM_FILE_COUNT) <> 0 then begin
|
|
if fmt_filecount_input <> nil then begin
|
|
text := lv_textarea_get_text(fmt_filecount_input);
|
|
if (text <> nil) and (text^ <> #0) then begin
|
|
if (stringSize(text) > 5) or (not isNumericStr(text)) then begin
|
|
set_fmt_param_error('File count must be a number.');
|
|
exit;
|
|
end;
|
|
value := stringToInt(text);
|
|
if (value = 0) or (value > 65535) then begin
|
|
set_fmt_param_error('File count must be from 1 to 65535.');
|
|
exit;
|
|
end;
|
|
params.Flags := params.Flags or FS_FORMAT_PARAM_FILE_COUNT;
|
|
params.FileCount := value;
|
|
paramPtr := @params;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if (fmt_label_input <> nil) and ((fs^.formatParamFlags and FS_FORMAT_PARAM_LABEL) <> 0) then begin
|
|
text := lv_textarea_get_text(fmt_label_input);
|
|
if (fs^.validateLabelCallback = nil) then exit;
|
|
if fs^.validateLabelCallback(text,normalized) <> eNone then begin
|
|
set_fmt_param_error('Use up to 11 ASCII characters without punctuation such as / or :'); exit;
|
|
end;
|
|
memcpy(PtrUInt(@normalized[0]),PtrUInt(@params.LabelText[0]),12);
|
|
params.Flags := params.Flags or FS_FORMAT_PARAM_LABEL; paramPtr := @params;
|
|
end;
|
|
|
|
closeMsgBox;
|
|
|
|
cbCtx := PFmtUICallbackCtx(kalloc(sizeof(TFmtUICallbackCtx)));
|
|
if cbCtx = nil then begin
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox, 'Out of memory');
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(active_mbox, 'OK'), @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
cbCtx^.SessionID := ui_session_id;
|
|
cbCtx^.VolumeIdx := sel_vol_idx;
|
|
cbCtx^.Kind := 0; cbCtx^.DeviceIdx := sel_dev_idx;
|
|
|
|
{ Submit async format — returns immediately, fmt_done_cb only flips a flag. }
|
|
if not driver.storage.vol.mgr.format_volume_async(vol^.device, sel_vol_idx, fs^.sName, paramPtr,
|
|
@operation_done, cbCtx) then begin
|
|
kfree(void(cbCtx));
|
|
closeMsgBox;
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox, 'Format Failed');
|
|
lv_msgbox_add_text(active_mbox, 'Cannot start: device busy, unsupported geometry/options, or insufficient memory.');
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(active_mbox, 'OK'), @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
end else begin
|
|
operation_pending := true;
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox, 'Formatting');
|
|
lv_msgbox_add_text(active_mbox, 'Formatting is running in the background.');
|
|
lv_msgbox_add_text(active_mbox, 'The volume will remount automatically when complete.');
|
|
end;
|
|
end;
|
|
|
|
procedure fmt_cancel_cb(e: Plv_event); cdecl;
|
|
var code : uint32;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
closeMsgBox;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Button click handler — Add Partition
|
|
============================================================ }
|
|
procedure btn_add_part_cb(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
device : PStorage_Device;
|
|
mbox : Plv_obj;
|
|
body : Plv_obj;
|
|
btn_ok : Plv_obj;
|
|
btn_no : Plv_obj;
|
|
freeSec : uint32;
|
|
freeSlot: sint32;
|
|
infoTxt : pchar;
|
|
freeSlotCnt : uint32;
|
|
i : sint32;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
closeMsgBox;
|
|
|
|
device := driver.storage.mgr.get_device(sel_dev_idx);
|
|
if device = nil then exit;
|
|
|
|
{ Validate: writable }
|
|
if not device^.writable then begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Cannot Add Partition');
|
|
lv_msgbox_add_text(mbox, 'This device is read-only.');
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'OK');
|
|
lv_obj_add_event_cb(btn_no, @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
|
|
{ Validate: free slot available }
|
|
freeSlot := driver.storage.vol.mgr.find_free_slot(device);
|
|
if freeSlot < 0 then begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Cannot Add Partition');
|
|
lv_msgbox_add_text(mbox, 'All 4 partition slots are in use.');
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'OK');
|
|
lv_obj_add_event_cb(btn_no, @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
|
|
{ Validate: free space exists }
|
|
freeSec := driver.storage.vol.mgr.get_free_sector_count(device);
|
|
if freeSec = 0 then begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Cannot Add Partition');
|
|
lv_msgbox_add_text(mbox, 'No free space available on this device.');
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'OK');
|
|
lv_obj_add_event_cb(btn_no, @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
|
|
{ Count free slots }
|
|
freeSlotCnt := 0;
|
|
for i := 0 to 3 do begin
|
|
if driver.storage.vol.mgr.find_free_slot(device) >= 0 then
|
|
freeSlotCnt := freeSlotCnt + 1;
|
|
end;
|
|
{ Simpler: just use the volumes count }
|
|
if device^.volumes <> nil then
|
|
freeSlotCnt := 4 - device^.volumes^.Count
|
|
else
|
|
freeSlotCnt := 4;
|
|
|
|
{ Show dialog with context info }
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Add Partition');
|
|
|
|
infoTxt := uiConcat('Free space: ', formatSizePrecise(uint64(freeSec) * device^.sectorSize));
|
|
infoTxt := uiConcat(infoTxt, ' | Free slots: ');
|
|
infoTxt := uiConcat(infoTxt, uiInt(freeSlotCnt));
|
|
|
|
lv_msgbox_add_text(mbox, infoTxt);
|
|
lv_msgbox_add_text(mbox, 'Enter size (e.g. 100MB, 2GB) or leave blank for all free space:');
|
|
|
|
body := lv_msgbox_get_content(mbox);
|
|
add_textarea := lv_textarea_create(body);
|
|
lv_textarea_set_one_line(add_textarea, true);
|
|
lv_textarea_set_placeholder_text(add_textarea, formatSizeStr(uint64(freeSec) * device^.sectorSize));
|
|
lv_obj_set_width(add_textarea, 280);
|
|
add_err_lbl := nil;
|
|
|
|
btn_ok := lv_msgbox_add_footer_button(mbox, 'Create');
|
|
lv_obj_add_event_cb(btn_ok, @add_part_ok_cb, LV_EVENT_CLICKED, nil);
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'Cancel');
|
|
lv_obj_add_event_cb(btn_no, @add_part_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
end;
|
|
|
|
{ ============================================================
|
|
Button click handler — Format Volume
|
|
============================================================ }
|
|
procedure btn_format_cb(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
vol : PStorage_Volume;
|
|
mbox : Plv_obj;
|
|
body : Plv_obj;
|
|
btn_ok : Plv_obj;
|
|
btn_no : Plv_obj;
|
|
i : uint32;
|
|
fs : PFilesystem;
|
|
opts : pchar;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
closeMsgBox;
|
|
|
|
vol := driver.storage.vol.mgr.get_volume(sel_vol_idx);
|
|
if vol = nil then exit;
|
|
if driver.storage.vol.mgr.volume_is_busy(vol) then begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Cannot Format');
|
|
lv_msgbox_add_text(mbox, 'This volume is busy or already being formatted.');
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'OK');
|
|
lv_obj_add_event_cb(btn_no, @fmt_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
|
|
{ Check writable }
|
|
if (vol^.device <> nil) and (not vol^.device^.writable) then begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Cannot Format');
|
|
lv_msgbox_add_text(mbox, 'The underlying device is read-only.');
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'OK');
|
|
lv_obj_add_event_cb(btn_no, @fmt_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
|
|
{ Check filesystems available }
|
|
if driver.storage.fs.mgr.get_filesystem_count() = 0 then begin
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Cannot Format');
|
|
lv_msgbox_add_text(mbox, 'No filesystems are registered.');
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'OK');
|
|
lv_obj_add_event_cb(btn_no, @fmt_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
exit;
|
|
end;
|
|
|
|
mbox := lv_msgbox_create(lv_layer_top);
|
|
active_mbox := mbox;
|
|
lv_msgbox_add_title(mbox, 'Format Volume');
|
|
lv_msgbox_add_text(mbox, 'Select filesystem. This will erase all data on the volume.');
|
|
|
|
body := lv_msgbox_get_content(mbox);
|
|
addStatusLabel(body,
|
|
uiConcat('Volume size: ', formatSizePrecise(uint64(vol^.sectorCount) * vol^.sectorSize)),
|
|
160, 170, 190);
|
|
|
|
{ Build newline-separated options for dropdown }
|
|
opts := nil;
|
|
for i := 0 to driver.storage.fs.mgr.get_filesystem_count() - 1 do begin
|
|
fs := driver.storage.fs.mgr.get_filesystem(i);
|
|
if fs <> nil then begin
|
|
if opts = nil then
|
|
opts := fs^.sName
|
|
else begin
|
|
opts := uiConcat(opts, #10);
|
|
opts := uiConcat(opts, fs^.sName);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
fmt_dropdown := lv_dropdown_create(body);
|
|
lv_obj_set_width(fmt_dropdown, 280);
|
|
if opts <> nil then
|
|
lv_dropdown_set_options(fmt_dropdown, opts);
|
|
lv_obj_add_event_cb(fmt_dropdown, @fmt_fs_change_cb, LV_EVENT_VALUE_CHANGED, nil);
|
|
|
|
fmt_param_area := lv_obj_create(body);
|
|
lv_obj_remove_style_all(fmt_param_area);
|
|
lv_obj_set_width(fmt_param_area, 300);
|
|
lv_obj_set_style_layout(fmt_param_area, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(fmt_param_area, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_set_style_pad_row(fmt_param_area, 4, 0);
|
|
lv_obj_set_style_pad_all(fmt_param_area, 0, 0);
|
|
lv_obj_remove_flag(fmt_param_area, LV_OBJ_FLAG_SCROLLABLE);
|
|
fs := driver.storage.fs.mgr.get_filesystem(lv_dropdown_get_selected(fmt_dropdown));
|
|
rebuild_fmt_param_ui(fs);
|
|
|
|
btn_ok := lv_msgbox_add_footer_button(mbox, 'Format');
|
|
lv_obj_add_event_cb(btn_ok, @fmt_ok_cb, LV_EVENT_CLICKED, nil);
|
|
btn_no := lv_msgbox_add_footer_button(mbox, 'Cancel');
|
|
lv_obj_add_event_cb(btn_no, @fmt_cancel_cb, LV_EVENT_CLICKED, nil);
|
|
end;
|
|
|
|
{ ============================================================
|
|
Clear the detail panel
|
|
============================================================ }
|
|
procedure clearDetail;
|
|
begin
|
|
if detail <> nil then
|
|
lv_obj_clean(detail);
|
|
sel_mode := SEL_NONE;
|
|
end;
|
|
|
|
{ Find the volume that corresponds to a partition on a device }
|
|
function findVolumeForPartition(device: PStorage_Device; lbaStart: uint32): PStorage_Volume;
|
|
var
|
|
i : uint32;
|
|
vol : PStorage_Volume;
|
|
volCnt : uint32;
|
|
begin
|
|
findVolumeForPartition := nil;
|
|
volCnt := driver.storage.vol.mgr.get_volume_count();
|
|
if volCnt > 0 then for i := 0 to volCnt - 1 do begin
|
|
vol := driver.storage.vol.mgr.get_volume(i);
|
|
if vol = nil then continue;
|
|
if (vol^.device = device) and (vol^.sectorStart = lbaStart) then begin
|
|
findVolumeForPartition := vol;
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Build a single partition row with inline delete button.
|
|
Only called for non-empty partitions.
|
|
============================================================ }
|
|
procedure addPartitionRow(parent: Plv_obj; row_w: sint32;
|
|
slot: uint32; part: TPartition_table; sectorSize: uint32;
|
|
device: PStorage_Device; canDelete: boolean);
|
|
var
|
|
row : Plv_obj;
|
|
lbl : Plv_obj;
|
|
del_btn : Plv_obj;
|
|
sizeStr : pchar;
|
|
vol : PStorage_Volume;
|
|
freeStr : pchar;
|
|
totalB : uint64;
|
|
freeB : uint64;
|
|
begin
|
|
row := lv_obj_create(parent);
|
|
lv_obj_remove_style_all(row);
|
|
lv_obj_set_size(row, row_w - 24, 30);
|
|
lv_obj_remove_flag(row, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_style_layout(row, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
lv_obj_set_style_pad_column(row, 6, 0);
|
|
lv_obj_set_style_pad_left(row, 6, 0);
|
|
lv_obj_set_style_pad_right(row, 6, 0);
|
|
lv_obj_set_style_bg_color(row, lv_color_make(42, 46, 58), 0);
|
|
lv_obj_set_style_bg_opa(row, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_radius(row, 4, 0);
|
|
|
|
{ Slot number badge }
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, uiInt(slot));
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(100, 160, 255), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 20);
|
|
|
|
{ System ID }
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, uiConcat('ID:', uiInt(part.system_id)));
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(160, 170, 190), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 55);
|
|
|
|
{ Size }
|
|
totalB := uint64(part.sector_count) * sectorSize;
|
|
sizeStr := formatSizeStr(totalB);
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, sizeStr);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(220, 225, 240), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 70);
|
|
|
|
{ Free space — look up the corresponding volume }
|
|
vol := findVolumeForPartition(device, part.LBA_start);
|
|
if vol <> nil then begin
|
|
freeB := uint64(vol^.freeSectors) * vol^.sectorSize;
|
|
if (vol^.lifecycleFlags and STORAGE_VOLUME_FLAG_FREE_UNKNOWN) <> 0 then freeStr := 'Free: unknown'
|
|
else freeStr := uiConcat(formatSizeStr(freeB), ' free');
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, freeStr);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(100, 180, 130), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 80);
|
|
end else begin
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, 'No FS');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(120, 125, 145), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 80);
|
|
end;
|
|
|
|
{ Boot indicator }
|
|
if driver.storage.vol.mbr.get_bootable(@part) then begin
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, 'BOOT');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(100, 200, 120), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
|
|
{ Delete button }
|
|
if canDelete then begin
|
|
del_btn := makeDangerButton(row, 'Del', 42);
|
|
lv_obj_add_event_cb(del_btn, @row_del_click_cb, LV_EVENT_CLICKED, pointer(slot));
|
|
end;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Show device detail — device info + partition list + actions
|
|
============================================================ }
|
|
procedure showDeviceDetail(devIdx: uint32);
|
|
var
|
|
device : PStorage_Device;
|
|
btn_row : Plv_obj;
|
|
btn : Plv_obj;
|
|
dw : sint32;
|
|
i : uint32;
|
|
totalBytes : uint64;
|
|
freeBytes : uint64;
|
|
volCnt : uint32;
|
|
devVolCnt : uint32;
|
|
vol : PStorage_Volume;
|
|
fsName : pchar;
|
|
row : Plv_obj;
|
|
lbl : Plv_obj;
|
|
sizeStr : pchar;
|
|
freeStr : pchar;
|
|
totalB : uint64;
|
|
freeB : uint64;
|
|
begin
|
|
clearDetail;
|
|
sel_mode := SEL_DEVICE;
|
|
sel_dev_idx := devIdx;
|
|
|
|
device := driver.storage.mgr.get_device(devIdx);
|
|
if device = nil then begin
|
|
addStatusLabel(detail, 'Device not found.', 230, 80, 80);
|
|
exit;
|
|
end;
|
|
|
|
dw := WIN_W - SIDEBAR_W - 20;
|
|
|
|
{ ---- Device Info ---- }
|
|
addSectionHeader(detail, 'Device Info');
|
|
addInfoRow(detail, dw, 'Device Index', uiInt(devIdx));
|
|
addInfoRow(detail, dw, 'Controller', controllerStr(device^.controller));
|
|
addInfoRow(detail, dw, 'Writable', boolStr(device^.writable));
|
|
addInfoRow(detail, dw, 'Sector Size', uiConcat(uiInt(device^.sectorSize), ' bytes'));
|
|
totalBytes := uint64(device^.maxSectorCount) * device^.sectorSize;
|
|
addInfoRow(detail, dw, 'Total Size', formatSizePrecise(totalBytes));
|
|
|
|
{ Use the same cached partition geometry as Add Partition. Volumes may
|
|
still be undergoing filesystem probing after the device is published. }
|
|
devVolCnt := 0;
|
|
volCnt := driver.storage.vol.mgr.get_volume_count();
|
|
if volCnt > 0 then for i := 0 to volCnt - 1 do begin
|
|
vol := driver.storage.vol.mgr.get_volume(i);
|
|
if (vol <> nil) and (vol^.device = device) then begin
|
|
devVolCnt := devVolCnt + 1;
|
|
end;
|
|
end;
|
|
freeBytes := uint64(driver.storage.vol.mgr.get_free_sector_count(device)) * device^.sectorSize;
|
|
addInfoRow(detail, dw, 'Unallocated Space', formatSizePrecise(freeBytes));
|
|
addInfoRow(detail, dw, 'Volumes', uiInt(devVolCnt));
|
|
|
|
{ Usage bar }
|
|
if totalBytes > 0 then
|
|
addUsageBar(detail, dw, totalBytes - freeBytes, totalBytes);
|
|
|
|
addSeparator(detail, dw);
|
|
|
|
{ ---- Volumes on this device (from cached data — no disk I/O) ---- }
|
|
addSectionHeader(detail, 'Volumes');
|
|
|
|
if devVolCnt = 0 then
|
|
addStatusLabel(detail, 'No volumes found.', 120, 125, 145)
|
|
else begin
|
|
if volCnt > 0 then for i := 0 to volCnt - 1 do begin
|
|
vol := driver.storage.vol.mgr.get_volume(i);
|
|
if (vol = nil) or (vol^.device <> device) then continue;
|
|
|
|
row := lv_obj_create(detail);
|
|
lv_obj_remove_style_all(row);
|
|
lv_obj_set_size(row, dw - 24, 30);
|
|
lv_obj_remove_flag(row, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_style_layout(row, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
lv_obj_set_style_pad_column(row, 6, 0);
|
|
lv_obj_set_style_pad_left(row, 6, 0);
|
|
lv_obj_set_style_pad_right(row, 6, 0);
|
|
lv_obj_set_style_bg_color(row, lv_color_make(42, 46, 58), 0);
|
|
lv_obj_set_style_bg_opa(row, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_radius(row, 4, 0);
|
|
|
|
{ Filesystem name }
|
|
if vol^.filesystem <> nil then
|
|
fsName := vol^.filesystem^.sName
|
|
else
|
|
fsName := 'Unknown';
|
|
lbl := lv_label_create(row);
|
|
if vol^.labelText[0] <> #0 then lv_label_set_text(lbl,@vol^.labelText[0])
|
|
else lv_label_set_text(lbl, fsName);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(100, 160, 255), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 70);
|
|
|
|
{ LBA start }
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, uiConcat('LBA:', uiInt(vol^.sectorStart)));
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(160, 170, 190), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 80);
|
|
|
|
{ Size }
|
|
totalB := uint64(vol^.sectorCount) * vol^.sectorSize;
|
|
sizeStr := formatSizeStr(totalB);
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, sizeStr);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(220, 225, 240), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 70);
|
|
|
|
{ Free space }
|
|
freeB := uint64(vol^.freeSectors) * vol^.sectorSize;
|
|
if (vol^.lifecycleFlags and STORAGE_VOLUME_FLAG_FREE_UNKNOWN) <> 0 then freeStr := 'Free: unknown'
|
|
else freeStr := uiConcat(formatSizeStr(freeB), ' free');
|
|
lbl := lv_label_create(row);
|
|
lv_label_set_text(lbl, freeStr);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(100, 180, 130), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lv_obj_set_width(lbl, 80);
|
|
end;
|
|
end;
|
|
|
|
addSeparator(detail, dw);
|
|
|
|
{ ---- Action buttons ---- }
|
|
if device^.writable then begin
|
|
btn_row := lv_obj_create(detail);
|
|
lv_obj_remove_style_all(btn_row);
|
|
lv_obj_set_size(btn_row, dw - 24, 38);
|
|
lv_obj_remove_flag(btn_row, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_style_layout(btn_row, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(btn_row, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_style_pad_column(btn_row, 8, 0);
|
|
lv_obj_set_flex_align(btn_row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
btn := makeButton(btn_row, 'Add Partition', 130);
|
|
lv_obj_add_event_cb(btn, @btn_add_part_cb, LV_EVENT_CLICKED, nil);
|
|
end else begin
|
|
addStatusLabel(detail, 'Device is read-only.', 160, 150, 130);
|
|
end;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Show volume detail — volume info + format action
|
|
============================================================ }
|
|
procedure label_save_cb(e : Plv_event); cdecl;
|
|
var vol : PStorage_Volume; ctx : PFmtUICallbackCtx; value : TVolumeLabel; err : TError;
|
|
begin
|
|
if (lv_event_get_code(e) <> LV_EVENT_CLICKED) or operation_pending then exit;
|
|
vol := driver.storage.vol.mgr.get_volume(label_target_index);
|
|
if (vol = nil) or (vol^.id <> label_target_id) or (vol^.filesystem = nil) then begin
|
|
lv_label_set_text(add_err_lbl,'The selected volume is no longer available.'); exit;
|
|
end;
|
|
if vol^.filesystem^.validateLabelCallback = nil then exit;
|
|
err := vol^.filesystem^.validateLabelCallback(lv_textarea_get_text(fmt_label_input),value);
|
|
if err <> eNone then begin
|
|
lv_label_set_text(add_err_lbl,'Invalid label. Use ASCII letters, digits, spaces, _ or -.'); exit;
|
|
end;
|
|
ctx := PFmtUICallbackCtx(kalloc(sizeof(TFmtUICallbackCtx)));
|
|
if ctx = nil then begin lv_label_set_text(add_err_lbl,'Out of memory.'); exit; end;
|
|
ctx^.SessionID := ui_session_id; ctx^.VolumeIdx := label_target_index;
|
|
ctx^.Kind := 0; ctx^.DeviceIdx := sel_dev_idx;
|
|
err := driver.storage.vol.mgr.set_volume_label_async(vol^.device,label_target_index,@value[0],@operation_done,ctx);
|
|
if err <> eNone then begin
|
|
kfree(void(ctx)); lv_label_set_text(add_err_lbl,formatErrorName(err)); exit;
|
|
end;
|
|
operation_pending := true;
|
|
closeMsgBox;
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox,'Saving volume label');
|
|
lv_msgbox_add_text(active_mbox,'Updating the label on disk.');
|
|
end;
|
|
|
|
procedure label_edit_cb(e : Plv_event); cdecl;
|
|
var vol : PStorage_Volume; content : Plv_obj;
|
|
begin
|
|
if (lv_event_get_code(e) <> LV_EVENT_CLICKED) or operation_pending then exit;
|
|
vol := driver.storage.vol.mgr.get_volume(sel_vol_idx);
|
|
if (vol = nil) or (vol^.filesystem = nil) then exit;
|
|
if vol^.filesystem^.setLabelCallback = nil then exit;
|
|
closeMsgBox;
|
|
label_target_id := vol^.id; label_target_index := sel_vol_idx;
|
|
active_mbox := lv_msgbox_create(lv_layer_top);
|
|
lv_msgbox_add_title(active_mbox,'Rename Volume');
|
|
lv_msgbox_add_text(active_mbox,'Up to 11 ASCII characters, stored in uppercase. Leave blank to remove the label.');
|
|
content := lv_msgbox_get_content(active_mbox);
|
|
fmt_label_input := lv_textarea_create(content);
|
|
lv_textarea_set_one_line(fmt_label_input,true);
|
|
lv_textarea_set_max_length(fmt_label_input,11);
|
|
lv_textarea_set_text(fmt_label_input,@vol^.labelText[0]);
|
|
lv_obj_set_width(fmt_label_input,300);
|
|
add_err_lbl := lv_label_create(content); lv_label_set_text(add_err_lbl,'');
|
|
lv_obj_set_style_text_color(add_err_lbl,lv_color_make(230,80,80),0);
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(active_mbox,'Save'),@label_save_cb,LV_EVENT_CLICKED,nil);
|
|
lv_obj_add_event_cb(lv_msgbox_add_footer_button(active_mbox,'Cancel'),@add_part_cancel_cb,LV_EVENT_CLICKED,nil);
|
|
end;
|
|
|
|
procedure showVolumeDetail(volIdx: uint32);
|
|
var
|
|
vol : PStorage_Volume;
|
|
dw : sint32;
|
|
totalBytes : uint64;
|
|
freeBytes : uint64;
|
|
usedBytes : uint64;
|
|
fsName : pchar;
|
|
btn_row : Plv_obj;
|
|
btn : Plv_obj;
|
|
pctUsed : uint32;
|
|
devIdx : uint32;
|
|
i : uint32;
|
|
begin
|
|
clearDetail;
|
|
sel_mode := SEL_VOLUME;
|
|
sel_vol_idx := volIdx;
|
|
|
|
vol := driver.storage.vol.mgr.get_volume(volIdx);
|
|
if vol = nil then begin
|
|
addStatusLabel(detail, 'Volume not found.', 230, 80, 80);
|
|
exit;
|
|
end;
|
|
|
|
dw := WIN_W - SIDEBAR_W - 20;
|
|
|
|
addSectionHeader(detail, 'Volume Info');
|
|
addInfoRow(detail, dw, 'Volume Index', uiInt(volIdx));
|
|
if vol^.labelText[0] <> #0 then addInfoRow(detail,dw,'Label',@vol^.labelText[0])
|
|
else addInfoRow(detail,dw,'Label','Unlabelled');
|
|
|
|
{ Find parent device index }
|
|
devIdx := 0;
|
|
if driver.storage.mgr.get_device_count() > 0 then
|
|
for i := 0 to driver.storage.mgr.get_device_count() - 1 do begin
|
|
if driver.storage.mgr.get_device(i) = vol^.device then begin
|
|
devIdx := i;
|
|
break;
|
|
end;
|
|
end;
|
|
addInfoRow(detail, dw, 'Parent Device', uiConcat('Disk ', uiInt(devIdx)));
|
|
|
|
if vol^.filesystem <> nil then
|
|
fsName := vol^.filesystem^.sName
|
|
else
|
|
fsName := 'Unknown';
|
|
|
|
addInfoRow(detail, dw, 'Filesystem', fsName);
|
|
addInfoRow(detail, dw, 'Sector Start', uiInt(vol^.sectorStart));
|
|
addInfoRow(detail, dw, 'Sector Count', uiInt(vol^.sectorCount));
|
|
addInfoRow(detail, dw, 'Sector Size', uiConcat(uiInt(vol^.sectorSize), ' bytes'));
|
|
|
|
totalBytes := uint64(vol^.sectorCount) * vol^.sectorSize;
|
|
freeBytes := uint64(vol^.freeSectors) * vol^.sectorSize;
|
|
if freeBytes > totalBytes then freeBytes := totalBytes;
|
|
usedBytes := totalBytes - freeBytes;
|
|
|
|
addInfoRow(detail, dw, 'Total Size', formatSizePrecise(totalBytes));
|
|
if (vol^.lifecycleFlags and STORAGE_VOLUME_FLAG_FREE_UNKNOWN) <> 0 then begin
|
|
addInfoRow(detail, dw, 'Free Space', 'Unknown');
|
|
addInfoRow(detail, dw, 'Used Space', 'Unknown');
|
|
end else begin
|
|
addInfoRow(detail, dw, 'Free Space', formatSizePrecise(freeBytes));
|
|
addInfoRow(detail, dw, 'Used Space', formatSizePrecise(usedBytes));
|
|
|
|
if totalBytes > 0 then begin
|
|
pctUsed := (usedBytes * 100) div totalBytes;
|
|
addInfoRow(detail, dw, 'Usage', uiConcat(uiInt(pctUsed), '%'));
|
|
addUsageBar(detail, dw, usedBytes, totalBytes);
|
|
end;
|
|
end;
|
|
|
|
addInfoRow(detail, dw, 'Boot Drive', boolStr(vol^.isBootDrive));
|
|
|
|
addSeparator(detail, dw);
|
|
|
|
{ ---- Action buttons ---- }
|
|
btn_row := lv_obj_create(detail);
|
|
lv_obj_remove_style_all(btn_row);
|
|
lv_obj_set_size(btn_row, dw - 24, 38);
|
|
lv_obj_remove_flag(btn_row, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_style_layout(btn_row, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(btn_row, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_style_pad_column(btn_row, 8, 0);
|
|
lv_obj_set_flex_align(btn_row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
if (vol^.device <> nil) and vol^.device^.writable then begin
|
|
if driver.storage.vol.mgr.volume_is_formatting(vol) then
|
|
addStatusLabel(detail, 'Format in progress. The volume will remount when complete.', 210, 180, 110)
|
|
else begin
|
|
btn := makeButton(btn_row, 'Format', 100);
|
|
lv_obj_add_event_cb(btn, @btn_format_cb, LV_EVENT_CLICKED, nil);
|
|
if vol^.filesystem <> nil then if vol^.filesystem^.setLabelCallback <> nil then begin
|
|
btn := makeButton(btn_row,'Rename Volume',150);
|
|
lv_obj_add_event_cb(btn,@label_edit_cb,LV_EVENT_CLICKED,nil);
|
|
end;
|
|
end;
|
|
end else begin
|
|
addStatusLabel(detail, 'Device is read-only. Format disabled.', 160, 150, 130);
|
|
end;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Sidebar highlight
|
|
============================================================ }
|
|
procedure highlightSidebarBtn(btn: Plv_obj);
|
|
begin
|
|
if active_sidebar_btn <> nil then
|
|
lv_obj_set_style_border_width(active_sidebar_btn, 0, 0);
|
|
active_sidebar_btn := btn;
|
|
if btn <> nil then begin
|
|
lv_obj_set_style_border_width(btn, 2, 0);
|
|
lv_obj_set_style_border_color(btn, lv_color_make(100, 160, 255), 0);
|
|
end;
|
|
end;
|
|
|
|
procedure sidebar_dev_click_hl(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
idx : uint32;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
idx := uint32(lv_event_get_user_data(e));
|
|
highlightSidebarBtn(lv_event_get_target(e));
|
|
showDeviceDetail(idx);
|
|
end;
|
|
|
|
procedure sidebar_vol_click_hl(e: Plv_event); cdecl;
|
|
var
|
|
code : uint32;
|
|
idx : uint32;
|
|
begin
|
|
code := lv_event_get_code(e);
|
|
if code <> LV_EVENT_CLICKED then exit;
|
|
idx := uint32(lv_event_get_user_data(e));
|
|
highlightSidebarBtn(lv_event_get_target(e));
|
|
showVolumeDetail(idx);
|
|
end;
|
|
|
|
{ ============================================================
|
|
Sidebar — build/rebuild the device and volume list
|
|
============================================================ }
|
|
procedure refreshSidebar;
|
|
var
|
|
i, j : uint32;
|
|
devCnt : uint32;
|
|
volCnt : uint32;
|
|
device : PStorage_Device;
|
|
vol : PStorage_Volume;
|
|
btn : Plv_obj;
|
|
lbl : Plv_obj;
|
|
hdr : Plv_obj;
|
|
sizeStr : pchar;
|
|
begin
|
|
if sidebar = nil then exit;
|
|
active_sidebar_btn := nil;
|
|
lv_obj_clean(sidebar);
|
|
|
|
{ Sidebar title }
|
|
hdr := lv_label_create(sidebar);
|
|
lv_label_set_text(hdr, 'Storage');
|
|
lv_obj_set_style_text_color(hdr, lv_color_make(200, 205, 220), 0);
|
|
lv_obj_set_style_text_font(hdr, @lv_font_montserrat_14, 0);
|
|
|
|
devCnt := driver.storage.mgr.get_device_count();
|
|
if devCnt > 0 then for i := 0 to devCnt - 1 do begin
|
|
device := driver.storage.mgr.get_device(i);
|
|
if device = nil then continue;
|
|
|
|
{ Section label for this device }
|
|
addSectionHeader(sidebar, uiConcat('Disk ', uiInt(i)));
|
|
|
|
{ Clickable device row }
|
|
btn := lv_button_create(sidebar);
|
|
lv_obj_remove_style_all(btn);
|
|
lv_obj_set_size(btn, SIDEBAR_W - 24, 34);
|
|
lv_obj_set_style_bg_color(btn, lv_color_make(45, 50, 68), 0);
|
|
lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_radius(btn, 6, 0);
|
|
lv_obj_add_flag(btn, LV_OBJ_FLAG_CLICKABLE);
|
|
lv_obj_set_style_pad_left(btn, 10, 0);
|
|
lv_obj_set_style_pad_right(btn, 8, 0);
|
|
lv_obj_set_style_layout(btn, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(btn, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(btn, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
lbl := lv_label_create(btn);
|
|
lv_label_set_text(lbl, controllerStr(device^.controller));
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(210, 215, 230), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
|
|
sizeStr := formatSizeStr(uint64(device^.maxSectorCount) * device^.sectorSize);
|
|
lbl := lv_label_create(btn);
|
|
lv_label_set_text(lbl, sizeStr);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(140, 150, 170), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
|
|
lv_obj_add_event_cb(btn, @sidebar_dev_click_hl, LV_EVENT_CLICKED, pointer(i));
|
|
|
|
{ Auto-highlight if currently selected }
|
|
if (sel_mode = SEL_DEVICE) and (sel_dev_idx = i) then
|
|
highlightSidebarBtn(btn);
|
|
|
|
{ List volumes that belong to this device }
|
|
volCnt := driver.storage.vol.mgr.get_volume_count();
|
|
if volCnt > 0 then for j := 0 to volCnt - 1 do begin
|
|
vol := driver.storage.vol.mgr.get_volume(j);
|
|
if vol = nil then continue;
|
|
if vol^.device <> device then continue;
|
|
|
|
btn := lv_button_create(sidebar);
|
|
lv_obj_remove_style_all(btn);
|
|
lv_obj_set_size(btn, SIDEBAR_W - 36, 28);
|
|
lv_obj_set_style_bg_color(btn, lv_color_make(38, 42, 56), 0);
|
|
lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_radius(btn, 4, 0);
|
|
lv_obj_add_flag(btn, LV_OBJ_FLAG_CLICKABLE);
|
|
lv_obj_set_style_pad_left(btn, 14, 0);
|
|
lv_obj_set_style_pad_right(btn, 8, 0);
|
|
lv_obj_set_style_layout(btn, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(btn, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(btn, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
lbl := lv_label_create(btn);
|
|
if vol^.labelText[0] <> #0 then
|
|
lv_label_set_text(lbl,@vol^.labelText[0])
|
|
else if vol^.filesystem <> nil then
|
|
lv_label_set_text(lbl, vol^.filesystem^.sName)
|
|
else
|
|
lv_label_set_text(lbl, 'Volume');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(185, 195, 215), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
|
|
sizeStr := formatSizeStr(uint64(vol^.sectorCount) * vol^.sectorSize);
|
|
lbl := lv_label_create(btn);
|
|
lv_label_set_text(lbl, sizeStr);
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(120, 130, 150), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
|
|
lv_obj_add_event_cb(btn, @sidebar_vol_click_hl, LV_EVENT_CLICKED, pointer(j));
|
|
|
|
if (sel_mode = SEL_VOLUME) and (sel_vol_idx = j) then
|
|
highlightSidebarBtn(btn);
|
|
end;
|
|
end;
|
|
|
|
{ Empty state placeholder }
|
|
if devCnt = 0 then begin
|
|
lbl := lv_label_create(sidebar);
|
|
lv_label_set_text(lbl, 'No storage devices');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(120, 125, 145), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lbl := lv_label_create(sidebar);
|
|
lv_label_set_text(lbl, 'detected.');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(120, 125, 145), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
end;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Window close handler
|
|
============================================================ }
|
|
procedure diskutil_entry(ctx : PProcessContext);
|
|
begin
|
|
while (ctx^.State <> psFinished) and (ctx^.PendingMsg <> smKill) and (ctx^.PendingMsg <> smTerminate) do
|
|
proc.mgr.proc_yield;
|
|
end;
|
|
|
|
procedure onClose(wid: uint32);
|
|
begin
|
|
debug.tracer.push_trace('diskutil.onClose');
|
|
closeMsgBox;
|
|
releaseTextTemps;
|
|
operation_pending := false;
|
|
ui_session_id := ui_session_id + 1;
|
|
puint32(@fmt_done_flag)^ := 0;
|
|
puint32(@storage_dirty_flag)^ := 0;
|
|
if fmt_poll_timer <> nil then begin
|
|
lv_timer_delete(fmt_poll_timer);
|
|
fmt_poll_timer := nil;
|
|
end;
|
|
if storage_watch_id <> 0 then begin
|
|
driver.storage.vol.mgr.unwatch_lifecycle(storage_watch_id);
|
|
storage_watch_id := 0;
|
|
end;
|
|
if proc_pid <> 0 then begin
|
|
proc.mgr.kill(proc_pid);
|
|
proc_pid := 0;
|
|
end;
|
|
driver.video.windows.destroyWindow(wid);
|
|
win_id := 0;
|
|
sidebar := nil;
|
|
detail := nil;
|
|
active_sidebar_btn := nil;
|
|
debug.tracer.pop_trace;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Launch — create the window and populate it
|
|
============================================================ }
|
|
procedure launch;
|
|
var
|
|
scr_w, scr_h : sint32;
|
|
wx, wy : sint32;
|
|
content : Plv_obj;
|
|
lbl : Plv_obj;
|
|
ctx : PProcessContext;
|
|
begin
|
|
debug.tracer.push_trace('diskutil.launch');
|
|
|
|
if driver.video.windows.isWindowOpen(win_id) then begin
|
|
debug.tracer.pop_trace;
|
|
exit;
|
|
end;
|
|
|
|
scr_w := sint32(driver.video.frontBufferWidth);
|
|
scr_h := sint32(driver.video.frontBufferHeight);
|
|
wx := (scr_w - WIN_W) div 2;
|
|
wy := (scr_h - WIN_H) div 2 - 30;
|
|
|
|
win_id := driver.video.windows.createWindow(
|
|
'Disk Utility',
|
|
wx, wy, WIN_W, WIN_H,
|
|
@onClose,
|
|
nil
|
|
);
|
|
if win_id = 0 then begin
|
|
debug.tracer.pop_trace;
|
|
exit;
|
|
end;
|
|
|
|
content := driver.video.windows.getWindowContent(win_id);
|
|
if content = nil then begin
|
|
debug.tracer.pop_trace;
|
|
exit;
|
|
end;
|
|
|
|
{ Content: horizontal flex row for sidebar + detail }
|
|
lv_obj_set_style_layout(content, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(content, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_style_pad_all(content, 0, 0);
|
|
lv_obj_set_style_pad_column(content, 0, 0);
|
|
lv_obj_remove_flag(content, LV_OBJ_FLAG_SCROLLABLE);
|
|
|
|
{ ---- Sidebar ---- }
|
|
sidebar := lv_obj_create(content);
|
|
lv_obj_remove_style_all(sidebar);
|
|
lv_obj_set_size(sidebar, SIDEBAR_W, lv_pct(100));
|
|
lv_obj_set_style_bg_color(sidebar, lv_color_make(28, 31, 40), 0);
|
|
lv_obj_set_style_bg_opa(sidebar, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_pad_all(sidebar, 10, 0);
|
|
lv_obj_set_style_pad_row(sidebar, 4, 0);
|
|
lv_obj_set_style_layout(sidebar, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(sidebar, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_add_flag(sidebar, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_scrollbar_mode(sidebar, LV_SCROLLBAR_MODE_AUTO);
|
|
lv_obj_set_style_border_width(sidebar, 1, 0);
|
|
lv_obj_set_style_border_color(sidebar, lv_color_make(48, 52, 68), 0);
|
|
|
|
{ ---- Detail panel ---- }
|
|
detail := lv_obj_create(content);
|
|
lv_obj_remove_style_all(detail);
|
|
lv_obj_set_size(detail, WIN_W - SIDEBAR_W - 20, lv_pct(100));
|
|
lv_obj_set_style_bg_color(detail, lv_color_make(35, 38, 48), 0);
|
|
lv_obj_set_style_bg_opa(detail, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_pad_all(detail, 14, 0);
|
|
lv_obj_set_style_pad_row(detail, 6, 0);
|
|
lv_obj_set_style_layout(detail, LV_LAYOUT_FLEX, 0);
|
|
lv_obj_set_flex_flow(detail, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_add_flag(detail, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_scrollbar_mode(detail, LV_SCROLLBAR_MODE_AUTO);
|
|
|
|
{ Placeholder text }
|
|
lbl := lv_label_create(detail);
|
|
lv_label_set_text(lbl, 'Select a device or volume');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(120, 125, 145), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
lbl := lv_label_create(detail);
|
|
lv_label_set_text(lbl, 'from the sidebar.');
|
|
lv_obj_set_style_text_color(lbl, lv_color_make(120, 125, 145), 0);
|
|
lv_obj_set_style_text_font(lbl, @lv_font_montserrat_14, 0);
|
|
|
|
{ Reset state }
|
|
operation_pending := false;
|
|
sel_mode := SEL_NONE;
|
|
sel_dev_idx := 0;
|
|
sel_vol_idx := 0;
|
|
pending_del_slot := -1;
|
|
active_mbox := nil;
|
|
fmt_dropdown := nil;
|
|
fmt_param_area := nil;
|
|
fmt_cluster_input := nil;
|
|
fmt_filecount_input := nil;
|
|
fmt_label_input := nil;
|
|
fmt_param_error_lbl := nil;
|
|
add_textarea := nil;
|
|
add_err_lbl := nil;
|
|
active_sidebar_btn := nil;
|
|
fmt_done_flag := 0;
|
|
fmt_done_error := eNone;
|
|
fmt_done_vol_idx := 0;
|
|
storage_dirty_flag := 0;
|
|
fmt_poll_timer := lv_timer_create(@fmt_poll_cb, 50, nil);
|
|
if fmt_poll_timer = nil then begin onClose(win_id); exit; end;
|
|
storage_watch_id := driver.storage.vol.mgr.watch_lifecycle(@diskutil_storage_event, nil);
|
|
|
|
refreshSidebar;
|
|
|
|
{ Create process so app.diskutil appears in PS and is manageable }
|
|
ctx := proc.mgr.create('Disk Utility', @diskutil_entry, nil, 1);
|
|
if ctx <> nil then begin
|
|
proc_pid := ctx^.ProcessID;
|
|
driver.video.windows.setWindowOwner(win_id, ctx^.ProcessID);
|
|
end;
|
|
|
|
debug.tracer.pop_trace;
|
|
end;
|
|
|
|
{ ============================================================
|
|
Init — register with the driver.video.desktop program launcher
|
|
============================================================ }
|
|
procedure UnitTest;
|
|
var passed, failed, sectors, sectorSize : uint32;
|
|
procedure Assert(ok : boolean; name : pchar);
|
|
begin
|
|
if ok then Inc(passed) else begin Inc(failed); io.syslog.logln('DISKUTIL FAIL', name); end;
|
|
end;
|
|
begin
|
|
passed := 0; failed := 0;
|
|
sectors := 8388608; sectorSize := 512;
|
|
Assert(stringEquals(formatSizeStr(uint64(sectors)*sectorSize),'4 GB'),'4GB label');
|
|
sectors := 10485760;
|
|
Assert(stringEquals(formatSizePrecise(uint64(sectors)*sectorSize),'5 GB'),'5GB label');
|
|
releaseTextTemps;
|
|
Assert(TextTemps = nil,'temporary labels released');
|
|
Assert(parseSize('4GB',512) = 8388608, '4GB does not wrap to zero');
|
|
Assert(parseSize('5GB',512) = 10485760, '5GB does not wrap to 1GB');
|
|
Assert(parseSize('999999999999999999999GB',512) = 0, 'reject decimal overflow');
|
|
Assert(parseSize('2097152GB',512) = 0, 'reject LBA overflow');
|
|
Assert(parseSize('513B',512) = 0, 'reject fractional sectors');
|
|
Assert(parseSize('512B',0) = 0, 'reject zero sector size');
|
|
Assert(parseSize('',512) = 0, 'reject empty size');
|
|
io.syslog.log('DISKUTIL', 'Passed: '); io.syslog.writeint(passed);
|
|
io.syslog.writestring(' Failed: '); io.syslog.writeintln(failed);
|
|
end;
|
|
|
|
procedure init();
|
|
begin
|
|
debug.tracer.push_trace('diskutil.init');
|
|
win_id := 0;
|
|
proc_pid := 0;
|
|
sidebar := nil;
|
|
detail := nil;
|
|
sel_mode := SEL_NONE;
|
|
sel_dev_idx := 0;
|
|
sel_vol_idx := 0;
|
|
pending_del_slot := -1;
|
|
active_mbox := nil;
|
|
fmt_dropdown := nil;
|
|
fmt_param_area := nil;
|
|
fmt_cluster_input := nil;
|
|
fmt_filecount_input := nil;
|
|
fmt_label_input := nil;
|
|
fmt_param_error_lbl := nil;
|
|
add_textarea := nil;
|
|
add_err_lbl := nil;
|
|
active_sidebar_btn := nil;
|
|
fmt_poll_timer := nil;
|
|
fmt_done_flag := 0;
|
|
fmt_done_error := eNone;
|
|
fmt_done_vol_idx := 0;
|
|
storage_dirty_flag := 0;
|
|
storage_watch_id := 0;
|
|
ui_session_id := 1;
|
|
driver.video.desktop.registerProgram('Disk Utility', @launch);
|
|
debug.tracer.pop_trace;
|
|
end;
|
|
|
|
end.
|