public bool LoadFromFile(GR.Memory.ByteBuffer Data)
{
Characters.Clear();
MapData.Clear();
MapColorData.Clear();
if ((Data == null) ||
(Data.Length < 24) ||
(Data.ByteAt(0) != 'C') ||
(Data.ByteAt(1) != 'T') ||
(Data.ByteAt(2) != 'M'))
{
// not a valid CTM file
return(false);
}
int version = Data.ByteAt(3);
if ((version != 4) &&
(version != 5) &&
(version != 6) &&
(version != 7) &&
(version != 8))
{
System.Windows.Forms.MessageBox.Show("Currently only version 4, 5, 6 or 7 of Charpad project files is supported. Sorry!", "Unsupported version " + version);
return(false);
}
switch (version)
{
case 4:
return(LoadVersion4(Data));
case 5:
return(LoadVersion5(Data));
case 6:
// TODO!
return(LoadVersion5(Data));
case 7:
return(LoadVersion7(Data));
case 8:
default:
return(LoadVersion8(Data));
}
}
public override bool RenameFile(GR.Memory.ByteBuffer Filename, GR.Memory.ByteBuffer NewFilename)
{
_LastError = "";
int curTrack = TRACK_DIRECTORY;
int curSector = SECTOR_DIRECTORY;
while (true)
{
Track dirTrack = Tracks[curTrack - 1];
Sector sect = dirTrack.Sectors[curSector];
for (int i = 0; i < 8; ++i)
{
if (sect.Data.ByteAt(BYTES_PER_DIR_ENTRY * i + 2) != 0)
{
// non empty
bool filenameMatches = true;
for (int j = 0; j < 16; ++j)
{
if (Filename.ByteAt(j) != sect.Data.ByteAt(BYTES_PER_DIR_ENTRY * i + 5 + j))
{
filenameMatches = false;
break;
}
}
if (filenameMatches)
{
for (int j = 0; j < 16; ++j)
{
sect.Data.SetU8At(BYTES_PER_DIR_ENTRY * i + 5 + j, NewFilename.ByteAt(j));
}
return(true);
}
}
}
// find next dir sector
if (sect.Data.ByteAt(0) == 0)
{
// was last dir sector
_LastError = "file not found";
return(false);
}
curTrack = sect.Data.ByteAt(0);
curSector = sect.Data.ByteAt(1);
}
}
private void btnOK_Click(object sender, EventArgs e)
{
Filename = Util.ToFilename(editFilename.Text);
while ((Filename.Length > 0) &&
(Filename.ByteAt((int)Filename.Length - 1) == 32))
{
Filename.Truncate(1);
}
while (Filename.Length < 16)
{
Filename.AppendU8(0xa0);
}
DialogResult = DialogResult.OK;
Close();
}
public string DisassembleBinary(GR.Memory.ByteBuffer Data, int DataStartAddress, int ExportStartAddress, int Length, bool AddLineAddresses)
{
StringBuilder sb = new StringBuilder();
int wrapSize = 8;
while (Length >= wrapSize)
{
if (AddLineAddresses)
{
sb.Append(ExportStartAddress.ToString("X4") + ":");
}
sb.Append(" !byte ");
for (int i = 0; i < wrapSize; ++i)
{
sb.Append("$" + Data.ByteAt(ExportStartAddress - DataStartAddress + i).ToString("X2"));
if (i + 1 < wrapSize)
{
sb.Append(",");
}
}
//Debug.Log( outputB );
sb.Append("\r\n");
ExportStartAddress += wrapSize;
Length -= wrapSize;
}
if (Length > 0)
{
if (AddLineAddresses)
{
sb.Append(ExportStartAddress.ToString("X4") + ":");
}
sb.Append(" !byte ");
for (int i = 0; i < Length; ++i)
{
sb.Append("$" + Data.ByteAt(ExportStartAddress - DataStartAddress + i).ToString("X2"));
if (i + 1 < Length)
{
sb.Append(",");
}
}
//Debug.Log( outputB );
sb.Append("\r\n");
}
return(sb.ToString());
}
public override void ApplyDisplayDetails(GR.Memory.ByteBuffer Buffer)
{
GR.IO.MemoryReader memIn = Buffer.MemoryReader();
int numColumns = memIn.ReadInt32();
for (int i = 0; i < numColumns; ++i)
{
if (i < listResults.Columns.Count)
{
listResults.Columns[i].Width = memIn.ReadInt32();
}
}
listResultsSortColumn = memIn.ReadInt32();
listResults.Sorting = (SortOrder)memIn.ReadInt32();
}
public override Types.FileInfo LoadFile(GR.Memory.ByteBuffer Filename)
{
_LastError = "";
Types.FileInfo fileInfo = new C64Studio.Types.FileInfo();
foreach (FileEntry file in TapFiles)
{
if (file.Filename.Compare(Filename) == 0)
{
fileInfo.Filename = new GR.Memory.ByteBuffer(file.Filename);
fileInfo.Data = file.Data;
fileInfo.Type = C64Studio.Types.FileType.PRG;
return(fileInfo);
}
}
_LastError = "file not found";
return(null);
}
public GR.Memory.ByteBuffer Save()
{
GR.Memory.ByteBuffer bufferProject = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkProject = new GR.IO.FileChunk(Types.FileChunk.PROJECT);
// version 2 -> has adjusted debug start address (to get rid of 2049)
chunkProject.AppendU32(2);
chunkProject.AppendString(Settings.Name);
chunkProject.AppendString(Settings.Filename);
chunkProject.AppendU16(Settings.DebugPort);
chunkProject.AppendU16(0);// obsolete Settings.DebugStartAddress
chunkProject.AppendString(Settings.BuildTool);
chunkProject.AppendString(Settings.RunTool);
chunkProject.AppendString(Settings.MainDocument);
chunkProject.AppendString(Settings.CurrentConfig.Name);
if (Core.MainForm.ActiveElement != null)
{
chunkProject.AppendString(Core.MainForm.ActiveElement.Filename);
}
else
{
chunkProject.AppendString("");
}
bufferProject.Append(chunkProject.ToBuffer());
foreach (System.Windows.Forms.TreeNode node in Node.Nodes)
{
ProjectElement element = (ProjectElement)node.Tag;
bufferProject.Append(ElementToBuffer(element));
}
foreach (ProjectConfig config in Settings.GetConfigurations())
{
bufferProject.Append(config.Save());
}
foreach (var watch in Core.MainForm.m_DebugWatch.m_WatchEntries)
{
bufferProject.Append(watch.Save());
}
return(bufferProject);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkScreenInfo = new GR.IO.FileChunk(Types.FileChunk.CHARSET_SCREEN_INFO);
// version
chunkScreenInfo.AppendU32(0);
// width
chunkScreenInfo.AppendI32(ScreenWidth);
// height
chunkScreenInfo.AppendI32(ScreenHeight);
chunkScreenInfo.AppendString("");
chunkScreenInfo.AppendI32((int)Mode);
chunkScreenInfo.AppendI32(ScreenOffsetX);
chunkScreenInfo.AppendI32(ScreenOffsetY);
projectFile.Append(chunkScreenInfo.ToBuffer());
GR.IO.FileChunk chunkCharSet = new GR.IO.FileChunk(Types.FileChunk.CHARSET_DATA);
chunkCharSet.Append(CharSet.SaveToBuffer());
projectFile.Append(chunkCharSet.ToBuffer());
GR.IO.FileChunk chunkScreenMultiColorData = new GR.IO.FileChunk(Types.FileChunk.MULTICOLOR_DATA);
chunkScreenMultiColorData.AppendU8((byte)Mode);
chunkScreenMultiColorData.AppendU8((byte)BackgroundColor);
chunkScreenMultiColorData.AppendU8((byte)MultiColor1);
chunkScreenMultiColorData.AppendU8((byte)MultiColor2);
projectFile.Append(chunkScreenMultiColorData.ToBuffer());
GR.IO.FileChunk chunkScreenCharData = new GR.IO.FileChunk(Types.FileChunk.SCREEN_CHAR_DATA);
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenCharData.AppendU8((byte)(Chars[i] & 0xff));
}
projectFile.Append(chunkScreenCharData.ToBuffer());
GR.IO.FileChunk chunkScreenColorData = new GR.IO.FileChunk(Types.FileChunk.SCREEN_COLOR_DATA);
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenColorData.AppendU8((byte)(Chars[i] >> 8));
}
projectFile.Append(chunkScreenColorData.ToBuffer());
return(projectFile);
}
public override UInt32 ReadBlock(GR.Memory.ByteBuffer BufferTarget, UInt32 BytesToRead)
{
if (m_Stream == null)
{
return(0);
}
int bytesInCache = (int)m_Cache.Length - m_CacheBytesUsed;
// full in cache
if (BytesToRead <= bytesInCache)
{
BufferTarget.Resize(BytesToRead);
m_Cache.CopyTo(BufferTarget, m_CacheBytesUsed, (int)BytesToRead);
m_CacheBytesUsed += (int)BytesToRead;
return(BytesToRead);
}
UInt32 bytesRead = 0;
// partially in cache
BufferTarget.Resize((uint)bytesInCache);
m_Cache.CopyTo(BufferTarget, m_CacheBytesUsed, bytesInCache);
m_CacheBytesUsed += bytesInCache;
BytesToRead -= (uint)bytesInCache;
bytesRead = (UInt32)bytesInCache;
UInt32 BytesToReadNow = BytesToRead;
if (m_Stream.Position + BytesToRead > m_Stream.Length)
{
BytesToReadNow = (UInt32)(m_Stream.Length - m_Stream.Position);
}
UInt32 OriginalLength = (UInt32)BufferTarget.Length;
BufferTarget.Resize((UInt32)(BufferTarget.Length + BytesToReadNow));
m_Stream.Read(BufferTarget.Data(), (int)OriginalLength, (int)BytesToReadNow);
bytesRead += BytesToReadNow;
return(bytesRead);
}
public GR.Memory.ByteBuffer ToBuffer()
{
GR.Memory.ByteBuffer result = new GR.Memory.ByteBuffer();
result.AppendI32(Width);
result.AppendI32(Height);
result.AppendU32((uint)PixelFormat);
result.AppendI32(PaletteEntryCount);
for (int i = 0; i < PaletteEntryCount; ++i)
{
result.AppendU8(PaletteRed(i));
result.AppendU8(PaletteGreen(i));
result.AppendU8(PaletteBlue(i));
}
result.Append(m_ImageData);
return(result);
}
private bool DoSave(string Filename)
{
try
{
DisableFileWatcher();
GR.Memory.ByteBuffer data = DataFromHex();
GR.IO.File.WriteAllBytes(Filename, data);
}
catch (System.IO.IOException ex)
{
System.Windows.Forms.MessageBox.Show("Could not save file " + Filename + ".\r\n" + ex.ToString(), "Could not save file");
EnableFileWatcher();
return(false);
}
EnableFileWatcher();
return(true);
}
public BinaryDisplay(StudioCore Core, GR.Memory.ByteBuffer WorkData, bool AllowEditing, bool FixedWidth)
{
this.Core = Core;
DocumentInfo.UndoManager.MainForm = Core.MainForm;
InitializeComponent();
if (WorkData == null)
{
SetHexData(new GR.Memory.ByteBuffer());
}
else
{
SetHexData(WorkData);
}
this.AllowEditing = AllowEditing;
this.FixedWidth = FixedWidth;
hexView.ByteProvider.Changed += new EventHandler(ByteProvider_Changed);
}
public override bool HandleExport(ExportCharsetInfo Info, TextBox EditOutput, DocumentInfo DocInfo)
{
var sb = new StringBuilder();
int startLine = GR.Convert.ToI32(editExportBASICLineNo.Text);
if ((startLine < 0) ||
(startLine > 63999))
{
startLine = 10;
}
int lineOffset = GR.Convert.ToI32(editExportBASICLineOffset.Text);
if ((lineOffset < 0) ||
(lineOffset > 63999))
{
lineOffset = 10;
}
int wrapByteCount = GetExportWrapCount();
bool asHex = checkExportHex.Checked;
int wrapCharCount = GetExportCharCount();
List <int> exportIndices = Info.ExportIndices;
GR.Memory.ByteBuffer charSet = new GR.Memory.ByteBuffer();
foreach (int index in exportIndices)
{
charSet.Append(Info.Charset.Characters[index].Tile.Data);
}
if (asHex)
{
sb.Append(Util.ToBASICHexData(charSet, startLine, lineOffset, wrapByteCount, wrapCharCount));
}
else
{
sb.Append(Util.ToBASICData(charSet, startLine, lineOffset, wrapByteCount, wrapCharCount));
}
EditOutput.Font = new System.Drawing.Font(Core.MainForm.m_FontC64.Families[0], 16, System.Drawing.GraphicsUnit.Pixel);
EditOutput.Text = sb.ToString();
return(true);
}
public static void DisplayMultiColorChar(GR.Memory.ByteBuffer Data, int BGColor, int MColor1, int MColor2, int CharColor, CustomDrawControlContext Context)
{
// multicolor
if (CharColor < 8)
{
DisplayHiResChar(Data, BGColor, CharColor, Context);
return;
}
// single color
int charColor = CharColor - 8;
for (int j = 0; j < 8; ++j)
{
for (int i = 0; i < 4; ++i)
{
int pixelValue = (Data.ByteAt(j) & (3 << ((3 - i) * 2))) >> ((3 - i) * 2);
switch (pixelValue)
{
case 0:
pixelValue = BGColor;
break;
case 1:
pixelValue = MColor1;
break;
case 2:
pixelValue = MColor2;
break;
case 3:
pixelValue = charColor;
break;
}
Context.Graphics.FillRectangle(Types.ConstantData.Palette.ColorBrushes[pixelValue],
(i * Context.Bounds.Width) / 4,
(j * Context.Bounds.Height) / 8,
((i + 1) * Context.Bounds.Width) / 4 - (i * Context.Bounds.Width) / 4,
((j + 1) * Context.Bounds.Height) / 8 - (j * Context.Bounds.Height) / 8);
}
}
}
public static void DisplayVIC20Char(GR.Memory.ByteBuffer Data, Palette Palette, int BGColor, int MColor1, int MColor2, int CharColor, GR.Image.IImage TargetImage, int X, int Y)
{
// multicolor
if (CharColor < 8)
{
DisplayHiResChar(Data, Palette, BGColor, CharColor, TargetImage, X, Y);
return;
}
int charColor = CharColor - 8;
for (int j = 0; j < 8; ++j)
{
for (int i = 0; i < 4; ++i)
{
int pixelValue = (Data.ByteAt(j) & (3 << ((3 - i) * 2))) >> ((3 - i) * 2);
switch (pixelValue)
{
case 0:
pixelValue = BGColor;
break;
case 1:
// border color(!)
pixelValue = MColor1;
break;
case 2:
pixelValue = charColor;
break;
case 3:
pixelValue = MColor2;
break;
}
uint color = Palette.ColorValues[pixelValue];
TargetImage.SetPixel(X + i * 2, Y + j, color);
TargetImage.SetPixel(X + i * 2 + 1, Y + j, color);
}
}
}
private void Export()
{
System.Windows.Forms.SaveFileDialog saveDlg = new System.Windows.Forms.SaveFileDialog();
saveDlg.FileName = DocumentFilename;
saveDlg.Title = "Export binary data to";
saveDlg.Filter = "All Files|*.*";
if (DocumentInfo.Project != null)
{
saveDlg.InitialDirectory = DocumentInfo.Project.Settings.BasePath;
}
if (saveDlg.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return;
}
GR.Memory.ByteBuffer data = DataFromHex();
GR.IO.File.WriteAllBytes(saveDlg.FileName, data);
}
private void btnOpenBinary_Click(object sender, EventArgs e)
{
OpenFileDialog openDialog = new OpenFileDialog();
openDialog.Title = "Choose binary file";
if (openDialog.ShowDialog() == DialogResult.OK)
{
m_OpenedFilename = openDialog.FileName;
GR.Memory.ByteBuffer data = GR.IO.File.ReadAllBytes(openDialog.FileName);
if (data != null)
{
ushort loadAddress = 0x801;
if (System.IO.Path.GetExtension(openDialog.FileName).ToUpper() == ".PRG")
{
// treat first two bytes as load address
loadAddress = data.UInt16At(0);
data = data.SubBuffer(2);
}
m_Disassembler.SetData(data);
m_DisassemblyProject.Data = data;
editStartAddress.Text = "$" + loadAddress.ToString("X4");
int sysAddress = -1;
if (m_Disassembler.HasBASICJumpAddress(loadAddress, out sysAddress))
{
m_DisassemblyProject.JumpedAtAddresses.Add(sysAddress);
ListViewItem item = new ListViewItem();
FillItemFromAddress(item, sysAddress);
listJumpedAtAddresses.Items.Add(item);
}
SetHexData(data);
UpdateDisassembly();
}
}
}
public static void DisplayMega65FCMChar(GR.Memory.ByteBuffer Data, int BGColor, int CharColor, CustomDrawControlContext Context)
{
// single color
for (int j = 0; j < 8; ++j)
{
for (int i = 0; i < 8; ++i)
{
int colorIndex = Data.ByteAt(i + j * 8);
if (colorIndex < Context.Palette.ColorBrushes.Length)
{
Context.Graphics.FillRectangle(Context.Palette.ColorBrushes[colorIndex],
(i * Context.Bounds.Width) / 8,
(j * Context.Bounds.Height) / 8,
((i + 1) * Context.Bounds.Width) / 8 - (i * Context.Bounds.Width) / 8,
((j + 1) * Context.Bounds.Height) / 8 - (j * Context.Bounds.Height) / 8);
}
}
}
}
public void AddWatchEntry( WatchEntry Watch )
{
ListViewItem item = new ListViewItem();
item.Text = Watch.Name;
if ( Watch.IndexedX )
{
item.Text += ",x";
}
if ( Watch.IndexedY )
{
item.Text += ",y";
}
item.SubItems.Add( TypeToString( Watch ) );
if ( Watch.DisplayMemory )
{
item.SubItems.Add( "(unread)" );
m_WatchEntries.Add( Watch );
}
else if ( !Watch.DisplayMemory )
{
if ( Watch.SizeInBytes == 1 )
{
GR.Memory.ByteBuffer data = new GR.Memory.ByteBuffer( Watch.Address.ToString( "x02" ) );
Watch.CurrentValue = data;
item.SubItems.Add( data.ToString() );
}
else if ( Watch.SizeInBytes == 2 )
{
GR.Memory.ByteBuffer data = new GR.Memory.ByteBuffer( Watch.Address.ToString( "x04" ) );
Watch.CurrentValue = data;
item.SubItems.Add( data.ToString() );
}
}
else
{
item.SubItems.Add( "(unread)" );
m_WatchEntries.Add( Watch );
}
item.Tag = Watch;
listWatch.Items.Add( item );
}
private bool SaveProject(bool SaveAs)
{
string saveFilename = DocumentInfo.FullPath;
if ((string.IsNullOrEmpty(DocumentInfo.DocumentFilename)) ||
(SaveAs))
{
System.Windows.Forms.SaveFileDialog saveDlg = new System.Windows.Forms.SaveFileDialog();
saveDlg.Title = "Save Value Table Project as";
saveDlg.Filter = "Value Table Projects|*.valuetableproject|All Files|*.*";
if (DocumentInfo.Project != null)
{
saveDlg.InitialDirectory = DocumentInfo.Project.Settings.BasePath;
}
if (saveDlg.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return(false);
}
saveFilename = saveDlg.FileName;
if (!SaveAs)
{
DocumentInfo.DocumentFilename = saveDlg.FileName;
if (DocumentInfo.Element != null)
{
DocumentInfo.DocumentFilename = GR.Path.RelativePathTo(saveDlg.FileName, false, System.IO.Path.GetFullPath(DocumentInfo.Project.Settings.BasePath), true);
DocumentInfo.Element.Name = System.IO.Path.GetFileNameWithoutExtension(DocumentInfo.DocumentFilename);
DocumentInfo.Element.Node.Text = System.IO.Path.GetFileName(DocumentInfo.DocumentFilename);
DocumentInfo.Element.Filename = DocumentInfo.DocumentFilename;
}
saveFilename = DocumentInfo.FullPath;
}
}
GR.Memory.ByteBuffer dataToSave = SaveToBuffer();
if (!GR.IO.File.WriteAllBytes(saveFilename, dataToSave))
{
return(false);
}
Modified = false;
return(true);
}
public bool FromBuffer(GR.Memory.ByteBuffer SolutionData, string FromFile)
{
GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(SolutionData);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
if (chunk.Type != Types.FileChunk.SOLUTION)
{
return(false);
}
GR.IO.MemoryReader memChunk = chunk.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(memChunk))
{
GR.IO.MemoryReader memSubChunk = subChunk.MemoryReader();
switch (subChunk.Type)
{
case Types.FileChunk.SOLUTION_INFO:
Name = memSubChunk.ReadString();
Filename = memSubChunk.ReadString();
Filename = FromFile;
break;
case Types.FileChunk.SOLUTION_PROJECT:
{
string filename = memSubChunk.ReadString();
filename = GR.Path.Normalize(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Filename), filename), false);
Project project = MainForm.OpenProject(filename);
}
break;
}
}
}
return(true);
}
private void btnToBASICHex_Click(object sender, EventArgs e)
{
GR.Memory.ByteBuffer data = DataFromHex();
int lineDelta = GR.Convert.ToI32(editToBASICLineDelta.Text);
if (lineDelta <= 0)
{
lineDelta = 1;
}
int curLineNumber = GR.Convert.ToI32(editToBASICStartLine.Text);
if (curLineNumber < 0)
{
curLineNumber = 0;
}
textBinaryData.Text = Util.ToBASICHexData(data, curLineNumber, lineDelta);
}
public override bool Load(string Filename)
{
_LastError = "";
Clear();
GR.Memory.ByteBuffer data = GR.IO.File.ReadAllBytes(Filename);
if (data == null)
{
_LastError = "could not open/read file";
return(false);
}
if (data.Length < 2)
{
_LastError = "file size is too small";
return(false);
}
LoadAddress = data.UInt16At(0);
Data = new GR.Memory.ByteBuffer(data);
this.Filename = Util.ToFilename(System.IO.Path.GetFileNameWithoutExtension(Filename).ToUpper());
return(true);
}
private GR.Memory.ByteBuffer PadString(GR.Memory.ByteBuffer Text, int Digits, byte fillChar)
{
GR.Memory.ByteBuffer result = new GR.Memory.ByteBuffer();
int useCharCount = Digits;
if (Text.Length < useCharCount)
{
useCharCount = (int)Text.Length;
}
for (int i = 0; i < useCharCount; ++i)
{
result.AppendU8(Text.ByteAt(i));
}
while (result.Length < Digits)
{
result.AppendU8(fillChar);
}
return(result);
}
public override bool RenameFile(GR.Memory.ByteBuffer Filename, GR.Memory.ByteBuffer NewFilename)
{
_LastError = "";
int fileIndex = 0;
foreach (FileRecord file in FileRecords)
{
if (file.EntryType == 1)
{
if (file.Filename == Filename)
{
NewFilename.CopyTo(file.Filename, 0, 16);
return(true);
}
}
++fileIndex;
}
_LastError = "file not found";
return(false);
}
private GR.Memory.ByteBuffer DataFromHex()
{
Be.Windows.Forms.DynamicByteProvider dynProvider = (Be.Windows.Forms.DynamicByteProvider)hexView.ByteProvider;
List <byte> dataBytes = dynProvider.Bytes;
if (dataBytes.Count == 0)
{
return(new GR.Memory.ByteBuffer());
}
long dataStart = 0;
long dataLength = hexView.ByteProvider.Length;
GR.Memory.ByteBuffer data = new GR.Memory.ByteBuffer((uint)dataLength);
for (int i = 0; i < dataBytes.Count; ++i)
{
data.SetU8At(i, dataBytes[(int)dataStart + i]);
}
return(data);
}
internal void ImageToClipboard(IImage Image, int X, int Y, int Width, int Height)
{
if (Image == null)
{
return;
}
if ((X >= Image.Width) ||
(Width <= 0) ||
(Height <= 0) ||
(X + Width < X) ||
(Y >= Image.Height) ||
(Y + Height < Y))
{
return;
}
GR.Memory.ByteBuffer dibData2 = Image.GetImage(X, Y, Width, Height).CreateHDIBAsBuffer();
System.IO.MemoryStream ms2 = dibData2.MemoryStream();
System.Windows.Forms.Clipboard.SetData("DeviceIndependentBitmap", ms2);
}
public static void DisplayHiResChar(GR.Memory.ByteBuffer Data, int BGColor, int CharColor, GR.Image.IImage TargetImage, int X, int Y)
{
// single color
int colorIndex = 0;
for (int j = 0; j < 8; ++j)
{
for (int i = 0; i < 8; ++i)
{
if ((Data.ByteAt(j) & (1 << (7 - i))) != 0)
{
colorIndex = CharColor;
}
else
{
colorIndex = BGColor;
}
TargetImage.SetPixel(X + i, Y + j, (uint)colorIndex);
}
}
}
public override bool WriteFile(GR.Memory.ByteBuffer Filename, GR.Memory.ByteBuffer Content, Types.FileType Type)
{
_LastError = "";
int fileIndex = 0;
foreach (FileRecord file in FileRecords)
{
if (file.EntryType == 0)
{
// free slot found
file.EntryType = 1;
file.C64FileType = Type;
if (Type == Types.FileType.PRG)
{
file.StartAddress = Content.UInt16At(0);
if (Content.Length < 2)
{
FileDatas[fileIndex] = new GR.Memory.ByteBuffer();
}
else
{
FileDatas[fileIndex] = Content.SubBuffer(2);
}
}
else
{
file.StartAddress = 0x0801;
FileDatas[fileIndex] = new GR.Memory.ByteBuffer(Content);
}
file.EndAddress = (ushort)(file.StartAddress + Content.Length);
file.FileOffset = 0;
file.Filename = Filename;
return(true);
}
++fileIndex;
}
_LastError = "tape image is full";
return(false);
}
private void btnReloadFile_Click(object sender, EventArgs e)
{
GR.Memory.ByteBuffer data = GR.IO.File.ReadAllBytes(m_OpenedFilename);
if (data != null)
{
ushort loadAddress = 0x801;
if (System.IO.Path.GetExtension(m_OpenedFilename).ToUpper() == ".PRG")
{
// treat first two bytes as load address
loadAddress = data.UInt16At(0);
data = data.SubBuffer(2);
}
m_Disassembler.SetData(data);
m_DisassemblyProject.Data = data;
SetHexData(data);
UpdateDisassembly();
}
}
