LisaList2

Advanced search  

News:

Want an XLerator? Please participate in the market research thread: https://lisalist2.com/index.php/topic,594.msg4180.html

Pages: [1]   Go Down

Author Topic: Writing new Lisa Office System applications  (Read 15144 times)

ried

  • Sr. Member
  • ****
  • Karma: +43/-0
  • Offline Offline
  • Posts: 207
Writing new Lisa Office System applications
« on: March 02, 2025, 12:26:05 am »

There's a dearth of LOS 3.1 software out there and, aside from a few odds and ends made by third-party providers, it seems like you have to run MacWorks in order to access a broad library of software. Why is that? Is Lisa Office System incomplete and lacking comparable APIs? It doesn't seem that way when using apps like LisaWrite and LisaDraw, which seem to be feature rich and perhaps even more capable than the subsequent Macintosh version.

On a whim, I asked Grok if it understands Pascal, whether it could write applications for Lisa Office System using Pascal, and whether or not Macintosh software written in Pascal could be rewritten and compiled for the Lisa.

Disclaimer: I am not a developer. The following is purely for curiosity's sake.

========= BEGIN =========

Me: Can you help me to write an application for the Lisa Office System using the PASCAL programming language?

Grok: I’d be happy to help you write a Pascal application for the Lisa Office System! Since the Lisa Office System was built using Pascal (specifically Lisa Pascal, with some extensions like Clascal for object-oriented features), we can create a simple example that aligns with its development style. The Lisa Workshop was the primary environment for coding such applications, and programs typically leveraged the Lisa Toolkit for GUI and system integration. However, without access to the full Lisa Toolkit or Workshop today, I’ll craft a basic Pascal program that mimics the structure and style of a Lisa application, assuming a simplified environment.

Let’s create a "Hello, Lisa!" application that could conceptually run on the Lisa Office System. It will include basic Pascal constructs and simulate a simple window-like output (though actual GUI code would require the Lisa Toolkit’s QuickDraw and event-handling libraries, which aren’t fully replicable here). I’ll keep it compatible with standard Pascal, noting where Lisa-specific features would typically be used.

Here’s the plan:
- Use Pascal’s structured programming features (e.g., procedures).
- Simulate a basic "window" output via text (since we can’t call the real Lisa GUI).
- Include comments to indicate where Lisa Toolkit calls would go.

### Pascal Code Example: HelloLisa.pas

```pascal
PROGRAM HelloLisa;

(* A simple Pascal program simulating a Lisa Office System application *)

CONST
  WindowWidth = 40;  (* Simulated window width *)
  WindowHeight = 10; (* Simulated window height *)

TYPE
  Point = RECORD
    x, y: INTEGER;
  END;

VAR
  windowOrigin: Point;  (* Origin point for our "window" *)

(* Procedure to simulate initializing a window *)
PROCEDURE InitWindow(VAR origin: Point);
BEGIN
  origin.x := 10;  (* Arbitrary screen position *)
  origin.y := 5;
  (* In Lisa Pascal with Toolkit, this would call QuickDraw’s InitWindow *)
  WRITELN('Initializing window at (', origin.x, ', ', origin.y, ')...');
END;

(* Procedure to draw a border - text simulation of a window frame *)
PROCEDURE DrawWindowBorder;
VAR
  i: INTEGER;
BEGIN
  (* Top border *)
  FOR i := 1 TO WindowWidth DO WRITE('-');
  WRITELN;
 
  (* Sides *)
  FOR i := 1 TO WindowHeight - 2 DO
  BEGIN
    WRITE('|');
    FOR i := 1 TO WindowWidth - 2 DO WRITE(' ');
    WRITELN('|');
  END;
 
  (* Bottom border *)
  FOR i := 1 TO WindowWidth DO WRITE('-');
  WRITELN;
END;

(* Procedure to display the message *)
PROCEDURE DisplayMessage;
BEGIN
  (* Simulate positioning text in the window *)
  WRITELN(' ');  (* Spacing to simulate inside window *)
  WRITELN('         Hello, Lisa!');  (* Centered message *)
  WRITELN(' ');  (* More spacing *)
  (* In Lisa Pascal, this would use QuickDraw’s DrawString *)
END;

(* Main program block *)
BEGIN
  WRITELN('Starting Lisa Office System Application...');
 
  (* Initialize the "window" *)
  InitWindow(windowOrigin);
 
  (* Draw the window frame *)
  DrawWindowBorder;
 
  (* Display the message inside the "window" *)
  DisplayMessage;
 
  WRITELN('Application complete.'); 
  (* In a real Lisa app, this would loop for events with GetNextEvent *)
END.
```

### Explanation

1. **Program Structure**:
   - The program follows Pascal’s structured style with a `PROGRAM` block, constants, types, variables, and procedures—hallmarks of Pascal as designed by Niklaus Wirth.
   - Lisa Pascal applications typically used units (like Pascal’s `UNIT` feature) for modularity, but I’ve kept this simple as a single file.

2. **Simulated Window**:
   - `InitWindow` sets a fictional origin point, mimicking how Lisa’s QuickDraw would position a window.
   - `DrawWindowBorder` uses text to simulate a rectangular window frame, since we can’t access the real GUI tools.
   - `DisplayMessage` prints "Hello, Lisa!" as if it’s inside the window.

3. **Lisa-Specific Notes**:
   - On the real Lisa, you’d use the Lisa Toolkit and QuickDraw for graphics (e.g., `InitGraf`, `OpenWindow`, `DrawString`).
   - Event handling (mouse clicks, menu selections) would involve an event loop with `GetNextEvent`, but here it’s a one-shot text output.
   - The Lisa Pascal compiler supported extensions like long integers and separate compilation, though we don’t need those here.

4. **Running It**:
   - You can compile this with a modern Pascal compiler like Free Pascal (`fpc HelloLisa.pas`) to test the output. On the Lisa, you’d use the Workshop, compile to Motorola 68000 object code, link with Lisa OS libraries, and install it as a tool via `InstallTool`.

### Output (Simulated)
Running this in a Pascal environment would produce something like:

```
Starting Lisa Office System Application...
Initializing window at (10, 5)...
----------------------------------------
|                                      |
|                                      |
|                                      |
|         Hello, Lisa!                 |
|                                      |
|                                      |
|                                      |
|                                      |
----------------------------------------
Application complete.
```

### Next Steps for a Real Lisa App
If you had a Lisa emulator (e.g., LisaEm) and the Workshop disks:
1. Boot into the Workshop environment.
2. Use the text editor to enter this code (or a more complex version with Toolkit calls).
3. Compile and link it against the Lisa OS libraries.
4. Install it to the Office System partition to run as a desktop tool.

Since the Lisa OS source was released in 2023 by the Computer History Museum, you could theoretically study the Toolkit and QuickDraw APIs to extend this with real GUI features—though that requires setting up an emulator and the original development tools.

Would you like to expand this further (e.g., add a mock menu or event loop), or do you have a specific feature in mind for your Lisa app? Let me know!

========= END =========

I subsequently asked Grok about porting Pascal apps for the Macintosh to Lisa Office System.

========= BEGIN =========

Me: I would like to port software written in PASCAL for the Macintosh to the Lisa Office System. Is that possible?

Grok: Yes, it’s theoretically possible to port Pascal software written for the Macintosh to the Lisa Office System, but there are several factors to consider due to differences in hardware, operating systems, and development environments. Since both platforms used Motorola 68000 processors and Pascal as a primary language, there’s a good foundation for compatibility. However, the Lisa Office System (and its Pascal dialect, Lisa Pascal) and the Macintosh System Software have distinct APIs, libraries, and architectural quirks that require careful adaptation. Let’s break this down and outline the process.

---

### Feasibility Assessment

1. **Common Ground**:
   - **Pascal**: Both the Lisa and early Macintosh relied heavily on Pascal. The Macintosh used MPW Pascal or earlier variants (like the Lisa-derived Pascal), while the Lisa used Lisa Pascal with extensions (e.g., Clascal for object-oriented features).
   - **68000 Processor**: Both systems share the same CPU architecture, so low-level assembly or machine code (if present) could be compatible with minor tweaks.
   - **QuickDraw**: The Macintosh’s graphics library originated from the Lisa, so any QuickDraw-based code has a decent chance of being portable with adjustments.

2. **Key Differences**:
   - **Operating System**:
     - The Lisa Office System (Lisa OS) integrates a desktop metaphor with a multitasking kernel and a unique file system, managed via the Lisa Workshop.
     - The Macintosh System Software (early versions like System 1–6) is single-tasking, simpler, and relies on the Toolbox ROM and System files.
   - **Development Environment**:
     - Lisa: Programs were written in the Lisa Workshop, using the Lisa Toolkit for GUI and system calls.
     - Macintosh: Programs used the Macintosh Programmer’s Workshop (MPW) or simpler tools like the Lisa Pascal compiler in early days, with the Toolbox APIs.
   - **GUI Libraries**:
     - Lisa Toolkit provides high-level abstractions for windows, menus, and events, tailored to Lisa OS.
     - Macintosh Toolbox offers similar but not identical APIs (e.g., `WindowManager`, `MenuManager`), optimized for its lighter OS.
   - **Memory and Hardware**:
     - Lisa has a larger memory footprint (minimum 512 KB, often 1 MB) and supports hardware like dual floppy drives or a hard disk.
     - Early Macs had tighter constraints (128 KB initially), influencing how software was written.

3. **Challenges**:
   - API calls (e.g., Toolbox vs. Lisa Toolkit) will differ, requiring rewrites for GUI and system interactions.
   - Event handling loops and memory management may need adjustment due to OS differences.
   - Lisa Pascal supports features like separate compilation and units, which might not align perfectly with Macintosh Pascal implementations.

---

### Steps to Port Macintosh Pascal Software to Lisa

Let’s assume you have a simple Macintosh Pascal program—say, a basic app with a window, menu, and some text output (like a "Hello, Mac" demo). Here’s how to approach porting it to the Lisa Office System:

#### 1. Analyze the Source Code
- **Identify Dependencies**: Check for Macintosh Toolbox calls (e.g., `InitGraf`, `NewWindow`, `DrawString`, `GetNextEvent`). These are the primary areas needing adaptation.
- **Isolate Core Logic**: Separate pure Pascal logic (e.g., calculations, data structures) from system-specific code. The core logic should port easily since it’s standard Pascal.
- **Check for Inline Assembly**: If the Mac code uses 68000 assembly (e.g., via `INLINE` directives), verify compatibility with Lisa’s memory model.

#### 2. Set Up the Lisa Environment
- **Emulator or Hardware**: Use a Lisa emulator like LisaEm with Lisa OS 7/7 and the Workshop installed, or a real Lisa if available.
- **Toolkit Access**: Ensure you have the Lisa Toolkit documentation or libraries (partially available via the 2023 Lisa OS source release). This defines Lisa’s equivalents to Toolbox calls.

#### 3. Map Macintosh Toolbox to Lisa Toolkit
Here’s a rough mapping of common Toolbox calls to Lisa Toolkit equivalents (based on historical documentation and Lisa OS design):

| Macintosh Toolbox Call       | Lisa Toolkit Equivalent (Hypothetical)         | Notes                                      |
|------------------------------|-----------------------------------------------|--------------------------------------------|
| `InitGraf`                   | `InitDrawing` or similar                    | Initializes QuickDraw graphics context     |
| `NewWindow`                  | `OpenWindow` or `NewWindow`                 | Creates a window; Lisa may use different parameters |
| `DrawString`                 | `DrawText` or QuickDraw equivalent          | Renders text; QuickDraw is shared but may differ in setup |
| `InitMenus`                  | `SetUpMenus` or similar                    | Initializes menu bar; Lisa menus are more complex |
| `GetNextEvent`               | `EventLoop` or `GetEvent`                   | Event handling; Lisa’s multitasking changes this |
| `DisposWindow`               | `CloseWindow`                              | Closes window; similar but Lisa may manage memory differently |

- **QuickDraw**: Since QuickDraw originated on the Lisa, most graphics calls (`MoveTo`, `LineTo`, etc.) should work with minor tweaks to initialization or coordinate systems.
- **Event Loop**: Replace the Mac’s `WHILE GetNextEvent(...) DO` loop with Lisa’s event-handling mechanism, which might involve a different structure due to multitasking.

#### 4. Rewrite System-Specific Code
- **Example Conversion**:
  Let’s say your Mac code looks like this:

  ```pascal
  PROGRAM HelloMac;
  USES
    QuickDraw, Windows, Events;
  VAR
    myWindow: WindowPtr;
  BEGIN
    InitGraf(@thePort);
    InitWindows;
    myWindow := NewWindow(NIL, Rect(50, 50, 300, 200), 'Hello, Mac', TRUE, documentProc, NIL, FALSE, 0);
    SetPort(myWindow);
    MoveTo(10, 20);
    DrawString('Hello from Macintosh!');
    REPEAT
      GetNextEvent(everyEvent, myEvent);
    UNTIL FALSE;
  END.
  ```

  For Lisa, you might adapt it to:

  ```pascal
  PROGRAM HelloLisa;
  (* Assuming Lisa Toolkit units *)
  VAR
    windowOrigin: Point;
    windowRect: Rect;
  PROCEDURE InitWindow;
  BEGIN
    (* Replace InitGraf and InitWindows with Lisa equivalents *)
    windowOrigin.x := 50; windowOrigin.y := 50;
    windowRect.top := 50; windowRect.left := 50;
    windowRect.bottom := 200; windowRect.right := 300;
    (* Hypothetical Lisa Toolkit call *)
    OpenWindow(windowRect, 'Hello, Lisa', TRUE);  (* Simplified *)
  END;
  BEGIN
    InitWindow;
    MoveTo(10, 20);  (* QuickDraw should still work *)
    DrawText('Hello from Lisa!');  (* Lisa’s text drawing *)
    (* Lisa event loop - might need a custom procedure *)
    REPEAT
      (* GetEvent or similar *)
    UNTIL FALSE;
  END.
  ```

- **Notes**: The Lisa Toolkit likely uses different window creation parameters and event structures. Without exact docs, this is speculative but follows Lisa’s design patterns.

#### 5. Compile and Test
- **Compile**: In the Lisa Workshop, compile the adapted `.pas` file (`Compile` command), link it with Lisa OS libraries (`Link`), and generate an executable.
- **Install**: Use `InstallTool` to add it to the Lisa Office System desktop.
- **Debug**: Test in the emulator or on hardware, adjusting for runtime errors (e.g., memory allocation or undefined Toolkit calls).

#### 6. Handle Edge Cases
- **Memory**: Lisa’s larger memory may require adjusting Mac code written for 128 KB constraints.
- **File I/O**: Replace Mac’s `FSRead`/`FSWrite` with Lisa’s file system calls (e.g., via the Pascal runtime or Toolkit).
- **Multitasking**: Ensure the app plays nicely with Lisa’s cooperative multitasking, unlike the Mac’s single-task focus.

---

### Practical Considerations
- **Toolkit Availability**: Without the full Lisa Toolkit, you’d need to reverse-engineer calls from the Lisa OS source or rely on preserved documentation (e.g., from Bitsavers or the Computer History Museum).
- **Time Investment**: Porting a small app might take a few hours to days; larger apps with heavy Toolbox reliance could take weeks.
- **Alternative**: If the Mac app is simple, rewriting it from scratch for Lisa might be faster than porting, using the Lisa Workshop’s examples as a guide.

---

### Is It Worth It?
If your goal is historical preservation, experimentation, or running the app on Lisa hardware/emulators, it’s absolutely doable with effort. For practical use, the Lisa’s obscurity makes it less viable unless you’re targeting a specific retro computing niche.

Do you have a specific Macintosh Pascal app in mind? If you share its purpose or code snippets, I can tailor the porting advice more precisely! What do you think—want to proceed with an example?

========= END =========

I am wondering if anyone has recently written apps for (or ported existing apps to) LOS, especially with new AI tools like Grok - and perhaps others like ChatGPT - to aid in the process. This does not seem... impossible, does it?
« Last Edit: March 02, 2025, 12:29:42 am by ried »
Logged

blusnowkitty

  • Sr. Member
  • ****
  • Karma: +79/-0
  • Offline Offline
  • Posts: 262
Re: Writing new Lisa Office System applications
« Reply #1 on: March 04, 2025, 05:06:14 pm »

I can't speak for Workshop specifically but modern AI tools do seem to show promise in helping understand weird high-level languages. I've been dabbling in IBM minicomputers lately; I was able to get an LLM to spit out almost perfectly valid 1977-era RPG II code for System/34 and System/36. It wasn't quite perfect but between period source code and reference books I have I was able to tweak the LLM output into valid, compilable RPG II code.

In my opinion though, the real barrier to entry for Lisa development is hardware access - did all the compiler bugs in LisaEm ever get fixed? If not, you have to have a 10MB ProFile or Widget; I don't believe Workshop is really usable in 5MB. I'm sure it's incredibly easy to create 10MB disk images in the new breed of emulators we have now but I've never been able to figure out how to set my X/Profile up for 10MB without crashing it.

Barring LisaEm and hardware issues, there's also the whole problem of having to learn the entire Pascal P-System in order to get anywhere with even writing a basic Hello World app. Not having any kind of terminal access in the Workshop is one of my biggest complaints in this day and age; I just want to xmodem files into the development environment and start hacking... Dropping them in a .dc42 image and sneakernetting is also acceptable.
« Last Edit: March 04, 2025, 05:32:40 pm by blusnowkitty »
Logged
You haven't lived until you've heard the sound of a Sony 400k drive.

ried

  • Sr. Member
  • ****
  • Karma: +43/-0
  • Offline Offline
  • Posts: 207
Re: Writing new Lisa Office System applications
« Reply #2 on: March 04, 2025, 08:17:51 pm »

It'll never be practical, given the small user base and number of real machines out there... but enthusiasts do all kinds of interesting niche things. A couple of things I'd like to see:

  • Networking. Would it be possible to implement the protocols necessary to support a lightweight email client? Terminal is cool and all, but email would be pretty amazing to see working in LOS. I'm sure TCP/IP and a web browser (even text only) is a lot to ask for.
  • Games. A while back we discussed Apple's only first-party game, Through the Looking Glass (aka Alice), which featured a funny sticker that reads "Works on Macintosh and Lisa" on the packaging. That got me wondering if it really did work on LOS, but nope... It works in the Macintosh XL mode only.

So far I've made use of the 800K disk driver, and just seeing one third-party app that had a UI was neat. But there are all kinds of fun little utilities that could be made or ported to run natively on LOS. I hope that either someone gives it a try, or I learn to do so myself someday. I do have a 5MB ProFile with Workshop and some other ResumeWriter source code on it... hmmm...  :P
Logged

warmech

  • Full Member
  • ***
  • Karma: +19/-1
  • Offline Offline
  • Posts: 33
Re: Writing new Lisa Office System applications
« Reply #3 on: March 04, 2025, 11:09:15 pm »

So, I've been brushing up on Pascal and have started working on a long-term side project for LOS: a Z-Machine interpreter. In a way, it's kind of a great little entry into LOS programming; I'm working on the non-graphical meat and potatoes of it in modern Pascal on Linux (vCPU opcodes, for instance) for the sake of convenience and plan on basically back-porting it to the Lisa's Pascal in Toolkit. Once I'm back to working on the Lisa, I'll work on implementing windowing and I/O. In the end, it will probably require a full 1MB of RAM due to a) LOS' overhead, b) the larger of the Infocom games pushing over 128K+ of RAM (can't recall the largest, but I know they wouldn't run on the C128 due to this), and c) that I am not a good programmer. I'm mostly interested in trying my hand at this because it's Lisa-specific properties are fairly... simple? A window, text output, a prompt, and a basic menu system to handle opening/closing games and saving/loading files. If anyone wants to build in transcription, printouts, etc., I'll leave that to them - Frotz, this ain't.

I dunno, we'll see how it goes. This isn't getting released next week or anything; if it ever sees the light of day, it will probably be months and months before it would ever be in a position to call it "usable". You can chalk that up to item "c" above, lol.
« Last Edit: March 04, 2025, 11:13:17 pm by warmech »
Logged

AlexTheCat123

  • Sr. Member
  • ****
  • Karma: +82/-1
  • Offline Offline
  • Posts: 302
Re: Writing new Lisa Office System applications
« Reply #4 on: March 05, 2025, 12:02:07 pm »

I do have a 5MB ProFile with Workshop and some other ResumeWriter source code on it... hmmm...  :P


It might be worth archiving the contents of that ProFile. I've never even heard of ResumeWriter and I have no idea where that source code might've come from, but I bet it would be neat to take a look at.
Logged

ried

  • Sr. Member
  • ****
  • Karma: +43/-0
  • Offline Offline
  • Posts: 207
Re: Writing new Lisa Office System applications
« Reply #5 on: March 05, 2025, 08:34:04 pm »

I do have a 5MB ProFile with Workshop and some other ResumeWriter source code on it... hmmm...  :P


It might be worth archiving the contents of that ProFile. I've never even heard of ResumeWriter and I have no idea where that source code might've come from, but I bet it would be neat to take a look at.

I imaged that ProFile using BLU's serial XModem function a few months ago at another forum member's request. You can download the drive image here: https://drive.google.com/file/d/1rWZGRx-58m9pweutvcYS_huSyUkPb8WK/view?usp=share_link

We think the source code is related to this app...
Edit: The accent mark over the e is breaking the link, but you can find it here: https://macintoshgarden.org/search/node/resuméwriter

sigma7 edit - tried to fix url
« Last Edit: March 05, 2025, 11:37:24 pm by sigma7 »
Logged

AlexTheCat123

  • Sr. Member
  • ****
  • Karma: +82/-1
  • Offline Offline
  • Posts: 302
Re: Writing new Lisa Office System applications
« Reply #6 on: March 06, 2025, 01:26:40 pm »

Oh thanks, I had no idea it was already dumped!
Logged

TorZidan

  • Full Member
  • ***
  • Karma: +9/-0
  • Offline Offline
  • Posts: 29
Re: Writing new Lisa Office System applications
« Reply #7 on: March 06, 2025, 06:31:34 pm »

Just for fun, I converted the profile image above in dc42 format (using the LisaEm utility blu-to-dc42) and launched it in LisaEm. It works great. I was able to compile the source code in files Hill17.text and Kink17.text, but it refuses to execute it from the "(R)un" menu, most likely because the target platform is Macintosh (not Lisa) ?
« Last Edit: March 06, 2025, 06:33:42 pm by TorZidan »
Logged

stepleton

  • Sr. Member
  • ****
  • Karma: +146/-1
  • Offline Offline
  • Posts: 479
Re: Writing new Lisa Office System applications
« Reply #8 on: March 06, 2025, 07:38:34 pm »

That's almost certainly the case.

Congratulations, you are very probably the first person to compile this app in nearly four decades!
Logged

ried

  • Sr. Member
  • ****
  • Karma: +43/-0
  • Offline Offline
  • Posts: 207
Re: Writing new Lisa Office System applications
« Reply #9 on: March 24, 2025, 01:42:00 am »

I've been tinkering with Grok 3 beta some more and it's convinced me that I need to compile the proof-of-concept app that it wrote using Workshop.

I am trying to avoid manually typing 300 lines of Pascal, if at all possible.

Question for the room...

What is the easiest way to get text (Grok-generated LisaPascal) from my Apple Silicon Mac over to Workshop on the Lisa? Is there one?
Logged

stepleton

  • Sr. Member
  • ****
  • Karma: +146/-1
  • Offline Offline
  • Posts: 479
Re: Writing new Lisa Office System applications
« Reply #10 on: March 24, 2025, 05:15:31 am »

With a USB serial adaptor plugged into your Mac, you can connect to one of your Lisa's serial ports and use the Transfer program in the Workshop to establish a serial link between the two computers. With a serial port program on the Mac (about which I can't really make many recommendations --- these options might work), you can paste or import the text over the link while the Transfer program on the Lisa "records" it to a file.

It is probably easier to do all of this in simulation; I've got the impression (without having tried it) that modern versions of LisaEm can compile software in the Workshop, which was not always the case.

Beyond that, I will sit this one out but watch with interest, until and unless you find a different AI. Absolutely no truck with X, its sibling companies, or its owner for me.
Logged

AlexTheCat123

  • Sr. Member
  • ****
  • Karma: +82/-1
  • Offline Offline
  • Posts: 302
Re: Writing new Lisa Office System applications
« Reply #11 on: March 24, 2025, 12:06:25 pm »

Yeah, the Transfer program is probably your best bet here (press T at the Workshop main menu to access it). Just keep in mind that the Lisa has no idea what an LF is, so if your file has any linefeeds in it, then you'll need to remove them and replace them with CR's or else the Lisa will put a bunch of "unknown character" characters into your file. Also, in my experience, you start getting data corruption at anything above about 1200 baud, so don't go any higher than that. It's really solid at 1200 baud and below though; I've used it to transfer about 12MB of LOS source files to the Workshop over the past month with no data errors whatsoever!


There's another Workshop data transfer option called MacCom (run it by choosing R{un}MacCom), but I haven't had super great luck with it. It's supposed to allow you to transfer files from Mac-formatted disks over to the Lisa, so you should theoretically be able to use ImportFL in Mini vMac to copy a bunch of text files over to an MFS-formatted floppy and then stick that into your Lisa. But I've never been able to get it to work right. Whenever I try to copy a file, it always starts copying a bit after the beginning of the file and stops copying after it has run past the end of the file, so the resulting file on the Lisa has a block of text missing at the beginning and an extra block from another random file on the disk appended onto the end. MacCom is probably more trouble than it's worth for a single file anyway (it would come more in handy for batch transfers, if I were able to get it to work), so I'd probably advise you to try Transfer unless you just want to play around with MacCom for fun!
Logged

TorZidan

  • Full Member
  • ***
  • Karma: +9/-0
  • Offline Offline
  • Posts: 29
Re: Writing new Lisa Office System applications
« Reply #12 on: March 24, 2025, 02:36:07 pm »

Feature request:
Write a tool for Windows, Linux, etc, that can add a file (e.g. a text file in this case) to a "profile.image" file.
Then you can use Alex's ESProFile to mount that profile.image on a real Lisa, and the file will be there.

Similarly, the tool should be able to extract files from a "profile.image" file.

Or do the above for floppy disk dc42 image files, and mount them on the Lisa using a FloppyEmu (I assume "Workshop" can access files on the floppy drive, but I don't know).

Hint: lisafsh-tool can "see" such files on dc42 floppy image files:
https://lisalist2.com/index.php?topic=154.0
I wonder if the Profile uses the same catalog structure as on floppies.

More hints: you should be able to use the LisaEm emulator, not a real Lisa, to compile your Pascal code. It can do all the above (read floppy and profile image files, has some serial port integration, not sure if/how it works).

« Last Edit: March 24, 2025, 03:46:52 pm by TorZidan »
Logged
Pages: [1]   Go Up