BOOL InitClipboard(struct InstData *data, ULONG flags)
{
struct IFFHandle *iff;
ENTER();
if((iff = AllocIFF()) != NULL)
{
SHOWVALUE(DBF_CLIPBOARD, iff);
if((iff->iff_Stream = (ULONG)OpenClipboard(0)) != 0)
{
SHOWVALUE(DBF_CLIPBOARD, iff->iff_Stream);
InitIFFasClip(iff);
if(OpenIFF(iff, flags) == 0)
{
data->iff = iff;
SHOWVALUE(DBF_CLIPBOARD, flags);
RETURN(TRUE);
return TRUE;
}
CloseClipboard((struct ClipboardHandle *)iff->iff_Stream);
}
FreeIFF(iff);
}
RETURN(FALSE);
return(FALSE);
}
static BOOL ClassInit(UNUSED struct Library *base)
{
if((LocaleBase = OpenLibrary("locale.library", 38)) &&
GETINTERFACE(ILocale, struct LocaleIFace *, LocaleBase))
{
// open the NListtree_mcp catalog
OpenCat();
#if !defined(__MORPHOS__)
{
struct Library *nbitmapMcc;
nbitmapCanHandleRawData = FALSE;
// we need at least NBitmap.mcc V15.8 to be able to let it handle raw image data
if((nbitmapMcc = OpenLibrary("mui/NBitmap.mcc", 0)) != NULL)
{
SHOWVALUE(DBF_ALWAYS, nbitmapMcc->lib_Version);
SHOWVALUE(DBF_ALWAYS, nbitmapMcc->lib_Revision);
if(nbitmapMcc->lib_Version > 15 || (nbitmapMcc->lib_Version == 15 && nbitmapMcc->lib_Revision >= 8))
nbitmapCanHandleRawData = TRUE;
CloseLibrary(nbitmapMcc);
}
SHOWVALUE(DBF_ALWAYS, nbitmapCanHandleRawData);
}
#endif
return TRUE;
}
return FALSE;
}
void ClipLine(struct line_node *line, struct InstData *data)
{
UWORD *styles = line->line.Styles;
UWORD *colors = line->line.Colors;
LONG error;
ENTER();
D(DBF_CLIPBOARD, "ClipLine()");
ClipInfo(line, data);
if(colors)
{
D(DBF_CLIPBOARD, "writing COLS");
error = PushChunk(data->iff, 0, ID_COLS, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
while(*colors != 0xffff)
{
colors += 2;
}
error = WriteChunkBytes(data->iff, line->line.Colors, colors - line->line.Colors);
SHOWVALUE(DBF_CLIPBOARD, error);
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(styles)
{
D(DBF_CLIPBOARD, "writing STYL");
error = PushChunk(data->iff, 0, ID_STYL, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
while(*styles != EOS)
{
styles += 2;
}
error = WriteChunkBytes(data->iff, line->line.Styles, styles - line->line.Styles);
SHOWVALUE(DBF_CLIPBOARD, error);
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
}
D(DBF_CLIPBOARD, "writing CHRS");
error = PushChunk(data->iff, 0, ID_CHRS, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
error = WriteChunkBytes(data->iff, line->line.Contents, line->line.Length);
SHOWVALUE(DBF_CLIPBOARD, error);
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
LEAVE();
}
void QtBinaryCalc::slot_test()
{
QBitArray *a = new QBitArray();
QBitArray *b = new QBitArray();
QBitArray *result = new QBitArray();
QString *resultString = new QString();
a->fill(0, 16);
b->fill(0, 16);
result->fill(0, 16);
for(int i = 0 ; i < this->numberA->getBytesAsBin().count() ; i++)
{
a->setBit(i, this->numberA->getBytesAsBin().at(i).digitValue() );
}
for(int i = 0 ; i < this->numberB->getBytesAsBin().count() ; i++)
{
b->setBit(i, this->numberB->getBytesAsBin().at(i).digitValue() );
}
*result = ~(*a);
SHOWVALUE(result, *result);
for ( int i = result->count()-1 ; i >= 0 ; i-- )
{
resultString->append( QString::number( (int)result->at(i) ) );
}
SHOWVALUE(resultString, *resultString);
SHOWVALUE(resultString->toInt(0, 2), resultString->toInt(0,2));//tu trzeba zrobic invert bitow 0->16, 1->15 itd
this->numberResult->slot_setValue(resultString->toInt());
SHOWVALUE(a, *a);
SHOWVALUE(b, *b);
}
void ClipInfo(struct line_node *line, struct InstData *data)
{
LONG error;
ENTER();
if(line->line.Flow != MUIV_TextEditor_Flow_Left)
{
D(DBF_CLIPBOARD, "writing FLOW");
error = PushChunk(data->iff, 0, ID_FLOW, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
error = WriteChunkBytes(data->iff, &line->line.Flow, 2);
SHOWVALUE(DBF_CLIPBOARD, error);
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(line->line.Separator)
{
D(DBF_CLIPBOARD, "writing SBAR");
error = PushChunk(data->iff, 0, ID_SBAR, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
error = WriteChunkBytes(data->iff, &line->line.Separator, 2);
SHOWVALUE(DBF_CLIPBOARD, error);
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(line->line.Color)
{
D(DBF_CLIPBOARD, "writing HIGH");
error = PushChunk(data->iff, 0, ID_HIGH, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
error = WriteChunkBytes(data->iff, &line->line.Color, 2);
SHOWVALUE(DBF_CLIPBOARD, error);
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
}
LEAVE();
}
LIBPROTO(__UserLibInit, int, REG(a6, __BASE_OR_IFACE), REG(a0, struct LibraryHeader *libBase))
{
int err = 1; /* Assume error condition */
ENTER();
SHOWPOINTER(DBF_STARTUP, __BASE_OR_IFACE_VAR);
SHOWPOINTER(DBF_STARTUP, libBase);
SHOWPOINTER(DBF_STARTUP, libBase->parent);
// lets set libBase as the ownBase for later reference
ownBase = libBase;
SHOWPOINTER(DBF_STARTUP, &ownBase);
SHOWPOINTER(DBF_STARTUP, ownBase);
// lets set the parent of libBase as our parentBase
parentBase = libBase->parent;
SHOWPOINTER(DBF_STARTUP, &parentBase);
SHOWPOINTER(DBF_STARTUP, parentBase),
// we have to initialize the libcmt stuff
__init_libcmt();
D(DBF_STARTUP, "Global parentBase variables:");
D(DBF_STARTUP, "---------------------------");
SHOWPOINTER(DBF_STARTUP, &parentBase->openssl_cs);
SHOWPOINTER(DBF_STARTUP, &parentBase->thread_hash);
SHOWPOINTER(DBF_STARTUP, parentBase->thread_hash);
SHOWPOINTER(DBF_STARTUP, &parentBase->LastThreadGroupID);
SHOWVALUE(DBF_STARTUP, parentBase->LastThreadGroupID);
D(DBF_STARTUP, "---------------------------");
ObtainSemaphore(&parentBase->openssl_cs);
ownBase->ThreadGroupID = ++(parentBase->LastThreadGroupID);
SHOWPOINTER(DBF_STARTUP, &ownBase->ThreadGroupID);
SHOWVALUE(DBF_STARTUP, ownBase->ThreadGroupID);
ReleaseSemaphore(&parentBase->openssl_cs);
#if defined(__amigaos4__)
if ((DOSBase = OpenLibrary("dos.library", 50))
&& (IntuitionBase = OpenLibrary("intuition.library", 50))
&& (UtilityBase = OpenLibrary("utility.library", 50))
&& (IDOS = (struct DOSIFace *)GetInterface(DOSBase,"main",1,NULL))
&& (IIntuition = (struct IntuitionIFace *)GetInterface(IntuitionBase,"main",1,NULL))
&& (IUtility = (struct UtilityIFace *)GetInterface(UtilityBase,"main",1,NULL)))
#else
if ((DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37))
&& (IntuitionBase = (struct IntuitionBase*)OpenLibrary("intuition.library", 36))
&& (UtilityBase = OpenLibrary("utility.library", 37)))
#endif
{
err = 0;
}
D(DBF_STARTUP, "Userlib err: %d %08lx", err, SysBase);
if (err != 0)
CALL_LFUNC(__UserLibCleanup, libBase);
RETURN(err);
return(err);
}
LIBPROTO(InitAmiSSLA, LONG, REG(a6, __BASE_OR_IFACE), REG(a0, struct TagItem *tagList))
{
AMISSL_STATE *state;
LONG err;
SHOWPOINTER(DBF_STARTUP, SysBase);
SHOWPOINTER(DBF_STARTUP, __BASE_OR_IFACE_VAR);
#if defined(DEBUG)
{
int i;
ULONG checksum;
D(DBF_STARTUP, "CAST TABLE CHECKSUMS in InitAmiSSLA()");
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table4[%ld] = %08lx", i, CAST_S_table4[i]);
checksum = checksum + CAST_S_table0[i];
}
D(DBF_STARTUP, "CHECKSUM table0: %08lx (addr: %08lx)", checksum, &CAST_S_table0[0]);
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table4[%ld] = %08lx", i, CAST_S_table4[i]);
checksum = checksum + CAST_S_table1[i];
}
D(DBF_STARTUP, "CHECKSUM table1: %08lx (addr: %08lx)", checksum, &CAST_S_table1[0]);
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table4[%ld] = %08lx", i, CAST_S_table4[i]);
checksum = checksum + CAST_S_table2[i];
}
D(DBF_STARTUP, "CHECKSUM table2: %08lx (addr: %08lx)", checksum, &CAST_S_table2[0]);
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table4[%ld] = %08lx", i, CAST_S_table4[i]);
checksum = checksum + CAST_S_table3[i];
}
D(DBF_STARTUP, "CHECKSUM table3: %08lx (addr: %08lx)", checksum, &CAST_S_table3[0]);
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table4[%ld] = %08lx", i, CAST_S_table4[i]);
checksum = checksum + CAST_S_table4[i];
}
D(DBF_STARTUP, "CHECKSUM table4: %08lx (addr: %08lx)", checksum, &CAST_S_table4[0]);
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table5[%ld] = %08lx", i, CAST_S_table5[i]);
checksum = checksum + CAST_S_table5[i];
}
D(DBF_STARTUP, "CHECKSUM table5: %08lx (addr: %08lx)", checksum, &CAST_S_table5[0]);
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table6[%ld] = %08lx", i, CAST_S_table6[i]);
checksum = checksum + CAST_S_table6[i];
}
D(DBF_STARTUP, "CHECKSUM table6: %08lx (addr: %08lx)", checksum, &CAST_S_table6[0]);
for(i=0,checksum=0; i < 256; i++)
{
// D(DBF_STARTUP, "CAST_S_table7[%ld] = %08lx", i, CAST_S_table7[i]);
checksum = checksum + CAST_S_table7[i];
}
D(DBF_STARTUP, "CHECKSUM table7: %08lx (addr: %08lx)", checksum, &CAST_S_table7[0]);
}
#endif
if((state = CreateAmiSSLState()))
{
int *errno_ptr;
state->SocketBase = (APTR)GetTagData(AmiSSL_SocketBase, (int)NULL, tagList);
#ifdef __amigaos4__
state->ISocket = (struct SocketIFace *)GetTagData(AmiSSL_ISocket, (int)NULL, tagList);
state->ISocketPtr = (struct SocketIFace **)GetTagData(AmiSSL_ISocketPtr, (ULONG)NULL, tagList);
state->IAmiSSL = __BASE_OR_IFACE_VAR;
state->AmiSSLBase = ((struct Interface *)__BASE_OR_IFACE_VAR)->Data.LibBase;
/* When ISocket[Ptr] is supplied, there is no need to specify SocketBase.
* This combination would confuse the code below which thinks that it
* needs to GetInterface if there is a SocketBase and also drops it later.
*/
if (state->ISocket || state->ISocketPtr)
state->SocketBase = NULL;
if (state->ISocketPtr)
state->ISocket = NULL; /* This is unneeded, ISocket should never be accessed directly */
else
state->ISocketPtr = &state->ISocket;
if(state->SocketBase)
{
// This means we are beeing called from a 68k program and we need to get the ppc interface to the library ourselves
if((*state->ISocketPtr = (struct SocketIFace *)GetInterface(state->SocketBase,"main",1,NULL)))
{
// All is good. Now we can make socket calls as if everything was ppc
}
else
{
// Ouch, we are using a 68k stack without an interface. Not much to do for now...
return 1; // Error
}
}
SHOWPOINTER(DBF_STARTUP, state->SocketBase);
SHOWPOINTER(DBF_STARTUP, state->ISocket);
SHOWPOINTER(DBF_STARTUP, &state->ISocket);
SHOWPOINTER(DBF_STARTUP, state->ISocketPtr);
#else
state->AmiSSLBase = __BASE_OR_IFACE_VAR;
state->TCPIPStackType = (LONG)GetTagData(AmiSSL_SocketBaseBrand, TCPIP_AmiTCP, tagList);
state->MLinkLock = (APTR)GetTagData(AmiSSL_MLinkLock, (int)NULL, tagList);
#endif
if((errno_ptr = (int *)GetTagData(AmiSSL_ErrNoPtr, (int)NULL, tagList)))
state->errno_ptr = errno_ptr;
SHOWPOINTER(DBF_STARTUP, SysBase);
SHOWPOINTER(DBF_STARTUP, __BASE_OR_IFACE_VAR);
SHOWPOINTER(DBF_STARTUP, state->SocketBase);
initialize_socket_errno(state);
err = 0;
}
else
err = 1;
SHOWVALUE(DBF_STARTUP, err);
return(err);
}
/*--------------------------*
* Merge two lines into one *
*--------------------------*/
BOOL MergeLines(struct line_node *line, struct InstData *data)
{
struct line_node *next;
char *newbuffer;
LONG visual, oldvisual, line_nr;
LONG emptyline = FALSE;
LONG color = line->line.Color;
UWORD flow = line->line.Flow;
UWORD separator = line->line.Separator;
ENTER();
data->HasChanged = TRUE;
if(line->line.Length == 1)
{
emptyline = TRUE;
color = line->next->line.Color;
flow = line->next->line.Flow;
separator = line->next->line.Separator;
}
visual = line->visual + line->next->visual;
if((newbuffer = MyAllocPooled(data->mypool, line->line.Length+line->next->line.Length+1)) != NULL)
{
memcpy(newbuffer, line->line.Contents, line->line.Length-1);
memcpy(newbuffer+line->line.Length-1, line->next->line.Contents, line->next->line.Length+1);
MyFreePooled(data->mypool, line->line.Contents);
MyFreePooled(data->mypool, line->next->line.Contents);
if(emptyline == TRUE)
{
if(line->line.Styles != NULL)
MyFreePooled(data->mypool, line->line.Styles);
line->line.Styles = line->next->line.Styles;
if(line->line.Colors != NULL)
MyFreePooled(data->mypool, line->line.Colors);
line->line.Colors = line->next->line.Colors;
}
else
{
UWORD *styles;
UWORD *styles1 = line->line.Styles;
UWORD *styles2 = line->next->line.Styles;
UWORD *colors;
UWORD *colors1 = line->line.Colors;
UWORD *colors2 = line->next->line.Colors;
UWORD length = 12;
if(styles1 != NULL)
length += *((long *)styles1-1) - 4;
if(styles2 != NULL)
length += *((long *)styles2-1) - 4;
if((styles = MyAllocPooled(data->mypool, length)) != NULL)
{
unsigned short* t_styles = styles;
unsigned short style = 0;
SHOWVALUE(DBF_CLIPBOARD, length);
SHOWVALUE(DBF_CLIPBOARD, styles);
SHOWVALUE(DBF_CLIPBOARD, styles1);
SHOWVALUE(DBF_CLIPBOARD, styles2);
if(styles2 != NULL)
{
unsigned short* t_styles2 = styles2;
while(*t_styles2++ == 1)
{
if(*t_styles2 > 0xff)
style &= *t_styles2++;
else
style |= *t_styles2++;
}
}
if(styles1 != NULL)
{
while(*styles1 != EOS)
{
if((*styles1 == line->line.Length) && ((~*(styles1+1) & style) == (*(styles1+1) ^ 0xffff)))
{
style &= *(styles1+1);
styles1 += 2;
}
else
{
*styles++ = *styles1++;
*styles++ = *styles1++;
}
}
SHOWVALUE(DBF_CLIPBOARD, line->line.Styles);
MyFreePooled(data->mypool, line->line.Styles);
}
if(styles2 != NULL)
{
while(*styles2 != EOS)
{
if((*styles2 == 1) && (!(*(styles2+1) & style)))
{
styles2 += 2;
}
else
{
*styles++ = *styles2++ + line->line.Length - 1;
*styles++ = *styles2++;
}
}
SHOWVALUE(DBF_CLIPBOARD, line->next->line.Styles);
MyFreePooled(data->mypool, line->next->line.Styles);
}
*styles = EOS;
line->line.Styles = t_styles;
}
length = 12;
if(colors1 != NULL)
length += *((long *)colors1-1) - 4;
if(colors2 != NULL)
length += *((long *)colors2-1) - 4;
if((colors = MyAllocPooled(data->mypool, length)) != NULL)
{
UWORD *t_colors = colors;
UWORD end_color = 0;
SHOWVALUE(DBF_CLIPBOARD, length);
SHOWVALUE(DBF_CLIPBOARD, colors);
SHOWVALUE(DBF_CLIPBOARD, colors1);
SHOWVALUE(DBF_CLIPBOARD, colors2);
if(colors1 != NULL)
{
while(*colors1 < line->line.Length && *colors1 != 0xffff)
{
*colors++ = *colors1++;
end_color = *colors1;
*colors++ = *colors1++;
}
SHOWVALUE(DBF_CLIPBOARD, line->line.Colors);
MyFreePooled(data->mypool, line->line.Colors);
}
if(end_color && (colors2 == NULL || *colors2 != 1))
{
*colors++ = line->line.Length;
*colors++ = 0;
}
if(colors2 != NULL)
{
if(*colors2 == 1 && *(colors2+1) == end_color)
colors2 += 2;
while(*colors2 != 0xffff)
{
*colors++ = *colors2++ + line->line.Length - 1;
*colors++ = *colors2++;
}
SHOWVALUE(DBF_CLIPBOARD, line->next->line.Colors);
MyFreePooled(data->mypool, line->next->line.Colors);
}
*colors = 0xffff;
line->line.Colors = t_colors;
}
}
line->line.Contents = newbuffer;
line->line.Length = strlen(newbuffer);
next = line->next;
line->next = line->next->next;
if(line->next != NULL)
line->next->previous = line;
oldvisual = line->visual;
line->visual = VisualHeight(line, data);
line->line.Color = color;
line->line.Flow = flow;
line->line.Separator = separator;
FreeLine(next, data);
line_nr = LineToVisual(line, data);
// handle that we have to scroll up/down due to word wrapping
// that occurrs when merging lines
if(visual > line->visual)
{
data->totallines -= 1;
if(line_nr+line->visual-1 < data->maxlines)
{
if(emptyline && line_nr > 0)
{
if(data->fastbackground)
{
ScrollUp(line_nr - 1, 1, data);
SetCursor(data->CPos_X, data->actualline, TRUE, data);
}
else
DumpText(data->visual_y+line_nr-1, line_nr-1, data->maxlines, TRUE, data);
}
else
{
if(data->fastbackground)
ScrollUp(line_nr + line->visual - 1, 1, data);
else
DumpText(data->visual_y+line_nr+line->visual-1, line_nr+line->visual-1, data->maxlines, TRUE, data);
}
}
}
else if(visual < line->visual)
{
data->totallines += 1;
if(line_nr+line->visual-1 < data->maxlines)
ScrollDown(line_nr + line->visual - 2, 1, data);
}
if(!(emptyline && (line_nr + line->visual - 1 < data->maxlines)))
{
LONG t_oldvisual = oldvisual;
LONG t_line_nr = line_nr;
ULONG c = 0;
while((--t_oldvisual) && (t_line_nr++ <= data->maxlines))
c = c + LineCharsWidth(line->line.Contents+c, data);
while((c < line->line.Length) && (t_line_nr <= data->maxlines))
c = c + PrintLine(c, line, t_line_nr++, TRUE, data);
}
if(line_nr + oldvisual == 1 && line->visual == visual-1)
{
data->visual_y--;
data->totallines -= 1;
if(data->fastbackground)
DumpText(data->visual_y, 0, visual-1, TRUE, data);
else
DumpText(data->visual_y, 0, data->maxlines, TRUE, data);
}
RETURN(TRUE);
return(TRUE);
}
else
{
RETURN(FALSE);
return(FALSE);
}
}
/*----------------------*
* Paste from Clipboard *
*----------------------*/
BOOL PasteClip (LONG x, struct line_node *actline, struct InstData *data)
{
struct line_node *line = NULL;
struct line_node *startline = NULL;
struct line_node *previous = NULL;
UWORD *styles = NULL;
UWORD *colors = NULL;
STRPTR textline;
BOOL newline = TRUE;
BOOL res = FALSE;
ENTER();
if(InitClipboard(data, IFFF_READ))
{
if(StopChunk(data->iff, ID_FTXT, ID_CHRS) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_FLOW) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_HIGH) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_SBAR) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_COLS) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_STYL) == 0 &&
StopChunk(data->iff, ID_FTXT, ID_CSET) == 0)
{
LONG error, codeset = 0;
UWORD flow = MUIV_TextEditor_Flow_Left;
UWORD color = FALSE;
UWORD separator = 0;
BOOL ownclip = FALSE;
LONG updatefrom;
while(TRUE)
{
struct ContextNode *cn;
error = ParseIFF(data->iff, IFFPARSE_SCAN);
SHOWVALUE(DBF_CLIPBOARD, error);
if(error == IFFERR_EOC)
continue;
else if(error)
break;
if((cn = CurrentChunk(data->iff)) != NULL)
{
switch (cn->cn_ID)
{
case ID_CSET:
D(DBF_CLIPBOARD, "reading FLOW");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if(cn->cn_Size >= 4)
{
/* Only the first four bytes are interesting */
if(ReadChunkBytes(data->iff, &codeset, 4) != 4)
{
codeset = 0;
}
SHOWVALUE(DBF_CLIPBOARD, codeset);
}
break;
case ID_FLOW:
D(DBF_CLIPBOARD, "reading FLOW");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if(cn->cn_Size == 2)
{
if(ReadChunkBytes(data->iff, &flow, 2) == 2)
if(flow > MUIV_TextEditor_Flow_Right)
flow = MUIV_TextEditor_Flow_Left;
SHOWVALUE(DBF_CLIPBOARD, flow);
}
break;
case ID_HIGH:
D(DBF_CLIPBOARD, "reading HIGH");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if (cn->cn_Size == 2)
{
error = ReadChunkBytes(data->iff, &color, 2);
SHOWVALUE(DBF_CLIPBOARD, color);
SHOWVALUE(DBF_CLIPBOARD, error);
}
break;
case ID_SBAR:
D(DBF_CLIPBOARD, "reading SBAR");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if (cn->cn_Size == 2)
{
error = ReadChunkBytes(data->iff, &separator, 2);
SHOWVALUE(DBF_CLIPBOARD, separator);
SHOWVALUE(DBF_CLIPBOARD, error);
}
break;
case ID_COLS:
D(DBF_CLIPBOARD, "reading COLS");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
if(colors)
{
MyFreePooled(data->mypool, colors);
colors = NULL;
}
// allocate one word more than the chunk tell us, because we terminate the array with an additional value
if(cn->cn_Size > 0 && (colors = (UWORD *)MyAllocPooled(data->mypool, cn->cn_Size + sizeof(UWORD))) != NULL)
{
error = ReadChunkBytes(data->iff, colors, cn->cn_Size);
SHOWVALUE(DBF_CLIPBOARD, error);
colors[cn->cn_Size / 2] = 0xffff;
}
break;
case ID_STYL:
D(DBF_CLIPBOARD, "reading STYL");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
ownclip = TRUE;
if(styles)
{
MyFreePooled(data->mypool, styles);
styles = NULL;
}
// allocate one word more than the chunk tell us, because we terminate the array with an additional value
if(cn->cn_Size > 0 && (styles = (UWORD *)MyAllocPooled(data->mypool, cn->cn_Size + sizeof(UWORD))) != NULL)
{
error = ReadChunkBytes(data->iff, styles, cn->cn_Size);
SHOWVALUE(DBF_CLIPBOARD, error);
styles[cn->cn_Size / 2] = EOS;
}
break;
case ID_CHRS:
{
D(DBF_CLIPBOARD, "reading CHRS");
SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
data->HasChanged = TRUE;
if(cn->cn_Size > 0 && !ownclip)
{
char *contents;
ULONG length = cn->cn_Size;
if((contents = (char *)MyAllocPooled(data->mypool, length + 1)) != NULL)
{
error = ReadChunkBytes(data->iff, contents, length);
SHOWVALUE(DBF_CLIPBOARD, error);
if(contents[length - 1] != '\n')
{
newline = FALSE;
}
else
{
length--;
}
contents[length] = '\0';
#if defined(__MORPHOS__)
if (codeset == CODESET_UTF8)
{
if (IS_MORPHOS2)
contents = utf8_to_ansi(data, contents);
}
#endif
if((line = ImportText(contents, data, &ImPlainHook, data->ImportWrap)))
{
if(!startline)
startline = line;
if(previous)
previous->next = line;
line->previous = previous;
line->visual = VisualHeight(line, data);
data->totallines += line->visual;
while(line->next)
{
line = line->next;
line->visual = VisualHeight(line, data);
data->totallines += line->visual;
}
previous = line;
}
MyFreePooled(data->mypool, contents);
}
}
else
{
ULONG length = cn->cn_Size;
if(length > 0 && (textline = (char *)MyAllocPooled(data->mypool, length + 2)) != NULL)
{
error = ReadChunkBytes(data->iff, textline, length);
SHOWVALUE(DBF_CLIPBOARD, error);
if (textline[length - 1] != '\n')
{
newline = FALSE;
textline[length] = '\n';
length++;
}
textline[length] = '\0';
if((line = AllocLine(data)))
{
line->next = NULL;
line->previous = previous;
line->line.Contents = textline;
line->line.Length = length;
line->visual = VisualHeight(line, data);
line->line.Color = color;
line->line.Flow = flow;
line->line.Separator = separator;
line->line.Styles = styles;
line->line.Colors = colors;
data->totallines += line->visual;
if(!startline)
startline = line;
if(previous)
previous->next = line;
previous = line;
}
else
{
if(styles)
MyFreePooled(data->mypool, (void *)styles);
if(colors)
MyFreePooled(data->mypool, (void *)colors);
}
}
else
{
if(styles)
MyFreePooled(data->mypool, styles);
if(colors)
MyFreePooled(data->mypool, (void *)colors);
}
styles = NULL;
colors = NULL;
flow = MUIV_TextEditor_Flow_Left;
color = FALSE;
separator = 0;
ownclip = FALSE;
}
}
break;
}
}
}
if(line)
{
BOOL oneline = FALSE;
SplitLine(x, actline, FALSE, NULL, data);
line->next = actline->next;
actline->next->previous = line;
actline->next = startline;
startline->previous = actline;
data->CPos_X = line->line.Length-1;
if(actline->next == line)
{
data->CPos_X += actline->line.Length-1;
oneline = TRUE;
}
if(!newline)
MergeLines(line, data);
MergeLines(actline, data);
if(oneline)
line = actline;
if(newline)
{
line = line->next;
data->CPos_X = 0;
}
data->actualline = line;
}
else
{
switch(error)
{
case IFFERR_MANGLED:
case IFFERR_SYNTAX:
case IFFERR_NOTIFF:
D(DBF_CLIPBOARD, "no FTXT clip!");
DoMethod(data->object, MUIM_TextEditor_HandleError, Error_ClipboardIsNotFTXT);
break;
default:
D(DBF_CLIPBOARD, "clipboard is empty!");
DoMethod(data->object, MUIM_TextEditor_HandleError, Error_ClipboardIsEmpty);
break;
}
}
data->update = TRUE;
ScrollIntoDisplay(data);
updatefrom = LineToVisual(actline, data)-1;
if(updatefrom < 0)
updatefrom = 0;
DumpText(data->visual_y+updatefrom, updatefrom, data->maxlines, TRUE, data);
if(data->update)
res = TRUE;
else
data->update = TRUE;
}
EndClipSession(data);
}
RETURN(res);
return res;
}
LONG CutBlock2(struct InstData *data, BOOL Clipboard, BOOL NoCut, struct marking *newblock, BOOL update)
{
LONG tvisual_y, error;
LONG startx, stopx;
LONG res = 0;
struct line_node *startline, *stopline;
ENTER();
startx = newblock->startx;
stopx = newblock->stopx;
startline = newblock->startline;
stopline = newblock->stopline;
//D(DBF_STARTUP, "CutBlock2: %ld-%ld %lx-%lx %ld %ld", startx, stopx, startline, stopline, Clipboard, NoCut);
if(startline != stopline)
{
struct line_node *c_startline = startline->next;
data->update = FALSE;
if(Clipboard == TRUE)
{
if(InitClipboard(data, IFFF_WRITE))
{
D(DBF_CLIPBOARD, "writing FORM");
error = PushChunk(data->iff, ID_FTXT, ID_FORM, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
ClipChars(startx, startline, startline->line.Length-startx, data);
}
else
{
Clipboard = FALSE;
}
}
while(c_startline != stopline)
{
if(Clipboard == TRUE)
{
ClipLine(c_startline, data);
}
if(NoCut == FALSE)
{
struct line_node *cc_startline = c_startline;
MyFreePooled(data->mypool, c_startline->line.Contents);
if(c_startline->line.Styles != NULL)
MyFreePooled(data->mypool, c_startline->line.Styles);
data->totallines -= c_startline->visual;
c_startline = c_startline->next;
//D(DBF_STARTUP, "FreeLine %08lx", cc_startline);
FreeLine(cc_startline, data);
}
else
c_startline = c_startline->next;
}
if(Clipboard == TRUE)
{
if(stopx != 0)
ClipChars(0, stopline, stopx, data);
EndClipSession(data);
}
if(NoCut == FALSE)
{
startline->next = stopline;
stopline->previous = startline;
//D(DBF_STARTUP, "RemoveChars: %ld %ld %08lx %ld", startx, stopx, startline, startline->line.Length);
if(startline->line.Length-startx-1 > 0)
RemoveChars(startx, startline, startline->line.Length-startx-1, data);
if(stopx != 0)
RemoveChars(0, stopline, stopx, data);
data->CPos_X = startx;
data->actualline = startline;
MergeLines(startline, data);
}
}
else
{
if(Clipboard == TRUE)
{
if(InitClipboard(data, IFFF_WRITE))
{
D(DBF_CLIPBOARD, "writing FORM");
error = PushChunk(data->iff, ID_FTXT, ID_FORM, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
ClipChars(startx, startline, stopx-startx, data);
EndClipSession(data);
}
if(update == TRUE && NoCut == TRUE)
{
MarkText(data->blockinfo.startx, data->blockinfo.startline, data->blockinfo.stopx, data->blockinfo.stopline, data);
goto end;
}
}
if(NoCut == FALSE)
{
data->CPos_X = startx;
RemoveChars(startx, startline, stopx-startx, data);
if(update == TRUE)
goto end;
}
}
tvisual_y = LineToVisual(startline, data)-1;
if(tvisual_y < 0 || tvisual_y > data->maxlines)
{
//D(DBF_STARTUP, "ScrollIntoDisplay");
ScrollIntoDisplay(data);
tvisual_y = 0;
}
if(update == TRUE)
{
//D(DBF_STARTUP, "DumpText! %ld %ld %ld", data->visual_y, tvisual_y, data->maxlines);
data->update = TRUE;
DumpText(data->visual_y+tvisual_y, tvisual_y, data->maxlines, TRUE, data);
}
res = tvisual_y;
end:
RETURN(res);
return res;
}
void ClipChars(LONG x, struct line_node *line, LONG length, struct InstData *data)
{
UWORD style[2] = {1, GetStyle(x-1, line)};
UWORD color[2] = {1, 0};
UWORD *colors = line->line.Colors;
LONG error;
ENTER();
D(DBF_CLIPBOARD, "ClipChars()");
ClipInfo(line, data);
if(colors)
{
D(DBF_CLIPBOARD, "writing COLS");
error = PushChunk(data->iff, 0, ID_COLS, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
while((*colors <= x) && (*colors != 0xffff))
{
color[1] = *(colors+1);
colors += 2;
}
if(color[1] != 0 && *colors-x != 1)
{
error = WriteChunkBytes(data->iff, color, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(*colors != 0xffff)
{
while(*colors <= x+length)
{
color[0] = *colors++ - x;
color[1] = *colors++;
error = WriteChunkBytes(data->iff, color, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
}
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
}
D(DBF_CLIPBOARD, "writing STYL");
error = PushChunk(data->iff, 0, ID_STYL, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
if(style[1] != 0)
{
unsigned short t_style = style[1];
if(t_style & BOLD)
{
style[1] = BOLD;
error = WriteChunkBytes(data->iff, style, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(t_style & ITALIC)
{
style[1] = ITALIC;
error = WriteChunkBytes(data->iff, style, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(t_style & UNDERLINE)
{
style[1] = UNDERLINE;
error = WriteChunkBytes(data->iff, style, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
}
if(line->line.Styles)
{
unsigned short *styles = line->line.Styles;
while((*styles <= x) && (*styles != EOS))
styles += 2;
if(*styles != EOS)
{
while(*styles <= x+length)
{
style[0] = *styles++ - x;
style[1] = *styles++;
error = WriteChunkBytes(data->iff, style, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
style[0] = length+1;
style[1] = GetStyle(x+length-1, line);
if(style[1] != 0)
{
unsigned short t_style = style[1];
if(t_style & BOLD)
{
style[1] = ~BOLD;
error = WriteChunkBytes(data->iff, style, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(t_style & ITALIC)
{
style[1] = ~ITALIC;
error = WriteChunkBytes(data->iff, style, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
if(t_style & UNDERLINE)
{
style[1] = ~UNDERLINE;
error = WriteChunkBytes(data->iff, style, 4);
SHOWVALUE(DBF_CLIPBOARD, error);
}
}
}
}
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
D(DBF_CLIPBOARD, "writing CHRS");
error = PushChunk(data->iff, 0, ID_CHRS, IFFSIZE_UNKNOWN);
SHOWVALUE(DBF_CLIPBOARD, error);
error = WriteChunkBytes(data->iff, line->line.Contents + x, length);
SHOWVALUE(DBF_CLIPBOARD, error);
error = PopChunk(data->iff);
SHOWVALUE(DBF_CLIPBOARD, error);
LEAVE();
}
static BOOL ClassInit(UNUSED struct Library *base)
{
ENTER();
if((DataTypesBase = OpenLibrary("datatypes.library",37)) &&
GETINTERFACE(IDataTypes,struct DataTypesIFace *,DataTypesBase) &&
(IFFParseBase = OpenLibrary("iffparse.library",37)) &&
GETINTERFACE(IIFFParse,struct IFFParseIFace *,IFFParseBase) &&
(LocaleBase = (APTR)OpenLibrary("locale.library",36)) &&
GETINTERFACE(ILocale,struct LocaleIFace *,LocaleBase))
{
BOOL success = TRUE;
// check for MUI 3.9+
if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 0))
{
lib_flags |= BASEFLG_MUI20;
// check for MUI 4.0+
if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 5500))
lib_flags |= BASEFLG_MUI4;
}
// on MUI 3.1 system's we do have to
// initialize our subclasses as well
#if defined(__amigaos3__)
if(!(lib_flags & BASEFLG_MUI20))
{
if(!initColoradjust() ||
!initPenadjust() ||
!initBackgroundadjust() ||
!initPoppen() ||
!initPopbackground())
{
success = FALSE;
}
}
#endif
if(success == TRUE)
{
// open the TheBar_mcp catalog
OpenCat();
LocalizeArray(regs,regIDs);
LocalizeArray(frames,frameIDs);
LocalizeArray(precisions,precisionIDs);
LocalizeArray(dismodes,dismodeIDs);
LocalizeArray(spacersSizes,spacersSizeIDs);
LocalizeArray(viewModes,viewModeIDs);
LocalizeArray(labelPoss,labelPosIDs);
// we open the cybgraphics.library but without failing if
// it doesn't exist
#if !defined(__amigaos4__)
CyberGfxBase = OpenLibrary("cybergraphics.library", 41);
/*
if(!GETINTERFACE(ICyberGfx, struct CyberGfxIFace *, CyberGfxBase))
{
CloseLibrary(CyberGfxBase);
CyberGfxBase = NULL;
}
*/
#endif
#if !defined(__MORPHOS__)
{
struct Library *nbitmapMcc;
nbitmapCanHandleRawData = FALSE;
// we need at least NBitmap.mcc V15.8 to be able to let it handle raw image data
if((nbitmapMcc = OpenLibrary("mui/NBitmap.mcc", 0)) != NULL)
{
SHOWVALUE(DBF_ALWAYS, nbitmapMcc->lib_Version);
SHOWVALUE(DBF_ALWAYS, nbitmapMcc->lib_Revision);
if(nbitmapMcc->lib_Version > 15 || (nbitmapMcc->lib_Version == 15 && nbitmapMcc->lib_Revision >= 8))
nbitmapCanHandleRawData = TRUE;
CloseLibrary(nbitmapMcc);
}
SHOWVALUE(DBF_ALWAYS, nbitmapCanHandleRawData);
}
#endif
lib_flags |= BASEFLG_Init;
RETURN(TRUE);
return TRUE;
}
}
ClassExpunge(base);
RETURN(FALSE);
return FALSE;
}
void rx_addredit(UNUSED struct RexxHost *host, struct RexxParams *params, enum RexxAction action, UNUSED struct RexxMsg *rexxmsg)
{
struct args *args = params->args;
ENTER();
switch(action)
{
case RXIF_INIT:
{
params->args = AllocVecPooled(G->SharedMemPool, sizeof(*args));
}
break;
case RXIF_ACTION:
{
struct ABookNode *abn;
abn = G->abook.arexxABN;
if(abn == NULL && G->ABookWinObject != NULL)
abn = (struct ABookNode *)xget(G->ABookWinObject, MUIA_AddressBookWindow_ActiveEntry);
SHOWVALUE(DBF_ABOOK, abn);
if(abn != NULL)
{
if(args->alias != NULL)
strlcpy(abn->Alias, args->alias, sizeof(abn->Alias));
if(args->name != NULL)
strlcpy(abn->RealName, args->name, sizeof(abn->RealName));
if(args->email != NULL)
strlcpy(abn->Address, args->email, sizeof(abn->Address));
if(args->pgp != NULL)
strlcpy(abn->PGPId, args->pgp, sizeof(abn->PGPId));
if(args->homepage != NULL)
strlcpy(abn->Homepage, args->homepage, sizeof(abn->Homepage));
if(args->street != NULL)
strlcpy(abn->Street, args->street, sizeof(abn->Street));
if(args->city != NULL)
strlcpy(abn->City, args->city, sizeof(abn->City));
if(args->country != NULL)
strlcpy(abn->Country, args->country, sizeof(abn->Country));
if(args->phone != NULL)
strlcpy(abn->Phone, args->phone, sizeof(abn->Phone));
if(args->comment != NULL)
strlcpy(abn->Comment, args->comment, sizeof(abn->Comment));
if(args->birthdate != NULL)
{
char dateStr[SIZE_SMALL];
// if the user supplied 0 as the birthdate, he wants to "delete" the current
// birthdate
if(*args->birthdate == 0)
abn->Birthday = 0;
else if(BirthdayToString(*args->birthdate, dateStr, sizeof(dateStr)) == TRUE)
abn->Birthday = *args->birthdate;
else
{
params->rc = RETURN_ERROR;
break;
}
}
if(args->image != NULL)
strlcpy(abn->Photo, args->image, sizeof(abn->Photo));
if(args->member != NULL && abn->type == ABNT_LIST)
{
char **p;
// free the list members in case we are told to replace them
if(args->add == FALSE)
{
dstrfree(abn->ListMembers);
abn->ListMembers = NULL;
}
for(p = args->member; *p != NULL; p++)
{
dstrcat(&abn->ListMembers, *p);
dstrcat(&abn->ListMembers, "\n");
}
}
G->abook.arexxABN = abn;
G->abook.modified = TRUE;
// update an existing address book window as well
if(G->ABookWinObject != NULL)
DoMethod(G->ABookWinObject, MUIM_AddressBookWindow_RedrawActiveEntry);
}
else
params->rc = RETURN_ERROR;
}
break;
case RXIF_FREE:
{
if(args != NULL)
FreeVecPooled(G->SharedMemPool, args);
}
break;
}
LEAVE();
}
