void Interpose(OBJECT z, int typ, OBJECT x, OBJECT y)
{ OBJECT encl;
New(encl, typ);
FposCopy(fpos(encl), fpos(y));
ReplaceNode(encl, z); Link(encl, z);
back(encl, COLM) = back(x, COLM);
fwd(encl, COLM) = fwd(x, COLM);
back(encl, ROWM) = back(y, ROWM);
fwd(encl, ROWM) = fwd(y, ROWM);
underline(encl) = underline(z);
} /* end Interpose */
static void createAndAppendFontSubMenu(const HitTestResult& result, ContextMenuItem& fontMenuItem)
{
ContextMenu fontMenu(result);
#if PLATFORM(MAC)
ContextMenuItem showFonts(ActionType, ContextMenuItemTagShowFonts, contextMenuItemTagShowFonts());
#endif
ContextMenuItem bold(CheckableActionType, ContextMenuItemTagBold, contextMenuItemTagBold());
ContextMenuItem italic(CheckableActionType, ContextMenuItemTagItalic, contextMenuItemTagItalic());
ContextMenuItem underline(CheckableActionType, ContextMenuItemTagUnderline, contextMenuItemTagUnderline());
ContextMenuItem outline(ActionType, ContextMenuItemTagOutline, contextMenuItemTagOutline());
#if PLATFORM(MAC)
ContextMenuItem styles(ActionType, ContextMenuItemTagStyles, contextMenuItemTagStyles());
ContextMenuItem showColors(ActionType, ContextMenuItemTagShowColors, contextMenuItemTagShowColors());
#endif
#if PLATFORM(MAC)
fontMenu.appendItem(showFonts);
#endif
fontMenu.appendItem(bold);
fontMenu.appendItem(italic);
fontMenu.appendItem(underline);
fontMenu.appendItem(outline);
#if PLATFORM(MAC)
fontMenu.appendItem(styles);
fontMenu.appendItem(*separatorItem());
fontMenu.appendItem(showColors);
#endif
fontMenuItem.setSubMenu(&fontMenu);
}
void QSGTextNode::addTextDecorations(Decoration decorations, const QPointF &position,
const QColor &color, qreal width, qreal lineThickness,
qreal underlinePos, qreal ascent)
{
QRectF line(position.x(), position.y() - lineThickness / 2.0, width, lineThickness);
if (decorations & Underline) {
int underlinePosition = qCeil(underlinePos);
QRectF underline(line);
underline.translate(0.0, underlinePosition);
appendChildNode(new QSGSimpleRectNode(underline, color));
}
if (decorations & Overline) {
QRectF overline(line);
overline.translate(0.0, -ascent);
appendChildNode(new QSGSimpleRectNode(overline, color));
}
if (decorations & StrikeOut) {
QRectF strikeOut(line);
strikeOut.translate(0.0, ascent / -3.0);
appendChildNode(new QSGSimpleRectNode(strikeOut, color));
}
}
void CRTFBuilder::normal()
{
bold(false);
italic(false);
underline(false);
strike(false);
}
void FontResource::updateModelFromLogFont(const LOGFONT& logFont) {
auto newFont = createFont (logFont);
mFont->fontName (newFont->fontName());
mFont->size (newFont->size());
mFont->bold (newFont->bold());
mFont->italic (newFont->italic());
mFont->underline (newFont->underline());
}
void delete_files( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
int ret;
uint32_t *pHandle;
uint32_t *pEnd;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
if (!validate_range( pHandles, pOpts, &pHandle, &pEnd)) {
if (pHandles)
free( pHandles);
return;
}
printf ( "\n Erase files %s\n", pDevInfo->Model);
printf ( " =========== %s\n", underline( pDevInfo->Model));
for (; pHandle <= pEnd; pHandle++) {
ret = GetObjectInfo( hCam, *pHandle, &pObjInfo);
if (ret) {
camcli_error( "Could not get info for handle %d", *pHandle);
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
continue;
}
if (pObjInfo->ObjectFormat == PTP_OFC_Association)
printf( " Handle %d is not a file - skipping...\n", *pHandle);
else {
ret = DeleteObject( hCam, *pHandle, 0);
if (ret == 0)
printf(" Erasing %3d (%s)... done\n", *pHandle, pObjInfo->Filename);
else {
camcli_error( "Could not delete handle %d - rc= %X",
*pHandle, ret);
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
}
}
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
void show_storage_info( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo)
{
CAMStorageInfoPtr pStorInfo = 0;
CAMStorageIDPtr pStorID = 0;
int i;
do {
if (GetStorageIds( hCam, &pStorID)) {
camcli_error( "Could not get storage IDs.");
break;
}
if (pStorID->cntStorageIDs == 0) {
camcli_error( "No storage IDs returned.");
break;
}
printf ( "\n Storage information %s\n", pDevInfo->Model);
printf ( " =================== %s\n", underline(pDevInfo->Model));
for (i = 0; i < pStorID->cntStorageIDs; i++) {
if (GetStorageInfo( hCam, pStorID->StorageIDs[i], &pStorInfo)) {
camcli_error( "Could not get storage info for id %d", pStorID->StorageIDs[i]);
continue;
}
printf ( " StorageID: 0x%04X\n", pStorID->StorageIDs[i]);
printf ( " StorageType: 0x%04X\t%s\n", pStorInfo->StorageType,
GetCodeName( pStorInfo->StorageType, CAM_STORAGE));
printf ( " FilesystemType: 0x%04X\t%s\n", pStorInfo->FilesystemType,
GetCodeName( pStorInfo->FilesystemType, CAM_FILESYSTEM));
printf ( " AccessCapability: 0x%04X\t%s\n", pStorInfo->AccessCapability,
GetCodeName( pStorInfo->AccessCapability, CAM_STORAGE_ACCESS));
printf ( " MaxCapacity: %lld\n", pStorInfo->MaxCapacity);
printf ( " FreeSpaceInBytes: %lld\n", pStorInfo->FreeSpaceInBytes);
printf ( " FreeSpaceInImages: 0x%04X\n", pStorInfo->FreeSpaceInImages);
printf ( " StorageDescription: %s\n", (pStorInfo->StorageDescription ?
pStorInfo->StorageDescription : "[none]"));
printf ( " VolumeLabel: %s\n\n", (pStorInfo->VolumeLabel ?
pStorInfo->VolumeLabel : "[none]"));
free( pStorInfo);
pStorInfo = 0;
}
} while (0);
if (pStorInfo);
free( pStorInfo);
if (pStorID)
free( pStorID);
return;
}
FontEffects& FontEffects::operator+=(const FontEffects& eff)
{
effects_.fx.weight=std::max(weight(), eff.weight());
effects_.fx.italic=(italic() || eff.italic());
effects_.fx.isSmall=(isSmall() || eff.isSmall());
effects_.fx.strike=(strikeOut() || eff.strikeOut());
effects_.fx.superscript=(superscript() || eff.superscript());
effects_.fx.subscript=(subscript() || eff.subscript());
effects_.fx.underline=std::max(underline(), eff.underline());
return *this;
}
/**
* This is a utility method to copy all the attributes of this
* TextItem to \a other TextItem.
*/
void TextItem::copyAttributesTo(TextItem *other) const
{
other->setDefaultTextColor(defaultTextColor());
other->setHoverBrush(hoverBrush());
other->setAcceptHoverEvents(acceptHoverEvents());
other->setAlignment(alignment());
other->setFont(font());
other->setBold(bold());
other->setItalic(italic());
other->setUnderline(underline());
other->setBackgroundBrush(backgroundBrush());
}
QString State::toCSS(const QString &gradientFolderPath, const QString &gradientFolderName, const QFont &baseFont)
{
QString css;
if (bold())
css += " font-weight: bold;";
if (italic())
css += " font-style: italic;";
if (underline() && strikeOut())
css += " text-decoration: underline line-through;";
else if (underline())
css += " text-decoration: underline;";
else if (strikeOut())
css += " text-decoration: line-through;";
if (textColor().isValid())
css += " color: " + textColor().name() + ";";
if (!fontName().isEmpty()) {
QString fontFamily = Tools::cssFontDefinition(fontName(), /*onlyFontFamily=*/true);
css += " font-family: " + fontFamily + ";";
}
if (fontSize() > 0)
css += " font-size: " + QString::number(fontSize()) + "px;";
if (backgroundColor().isValid()) {
// Get the colors of the gradient and the border:
QColor topBgColor;
QColor bottomBgColor;
Note::getGradientColors(backgroundColor(), &topBgColor, &bottomBgColor);
// Produce the CSS code:
QString gradientFileName = Basket::saveGradientBackground(backgroundColor(), font(baseFont), gradientFolderPath);
css += " background: " + bottomBgColor.name() + " url('" + gradientFolderName + gradientFileName + "') repeat-x;";
css += " border-top: solid " + topBgColor.name() + " 1px;";
css += " border-bottom: solid " + Tools::mixColor(topBgColor, bottomBgColor).name() + " 1px;";
}
if (css.isEmpty())
return "";
else
return " .tag_" + id() + " {" + css + " }\n";
}
void list_properties( CAMDeviceInfoPtr pDevInfo)
{
uint32_t ctr;
printf( "\n Properties %s\n", pDevInfo->Model);
printf( " ========== %s\n", underline( pDevInfo->Model));
for (ctr = 0; ctr < pDevInfo->cntDevicePropertiesSupported; ctr++){
printf( " 0x%04X: %s\n",
pDevInfo->DevicePropertiesSupported[ctr],
GetPropertyName( pDevInfo,
pDevInfo->DevicePropertiesSupported[ctr]));
}
}
void list_operations( CAMDeviceInfoPtr pDevInfo)
{
int i;
const char* name;
printf( "\n Operations %s\n", pDevInfo->Model);
printf( " ========== %s\n", underline( pDevInfo->Model));
for (i = 0; i < pDevInfo->cntOperationsSupported; i++) {
name = GetOperationName( pDevInfo,
pDevInfo->OperationsSupported[i]);
printf( " 0x%04X: %s\n",
pDevInfo->OperationsSupported[i],
(name ? name : "[unknown]"));
}
}
QFont State::font(QFont base)
{
if (bold())
base.setBold(true);
if (italic())
base.setItalic(true);
if (underline())
base.setUnderline(true);
if (strikeOut())
base.setStrikeOut(true);
if (!fontName().isEmpty())
base.setFamily(fontName());
if (fontSize() > 0)
base.setPointSize(fontSize());
return base;
}
void builder::node(label_t label, bool add_space) {
if (!label || !*label)
return;
auto text = label->get();
if (label->m_maxlen > 0 && text.length() > label->m_maxlen) {
text = text.substr(0, label->m_maxlen) + "...";
}
if ((label->m_overline.empty() && m_counters[syntaxtag::o] > 0) ||
(m_counters[syntaxtag::o] > 0 && label->m_margin > 0))
overline_close(true);
if ((label->m_underline.empty() && m_counters[syntaxtag::u] > 0) ||
(m_counters[syntaxtag::u] > 0 && label->m_margin > 0))
underline_close(true);
if (label->m_margin > 0)
space(label->m_margin);
if (!label->m_overline.empty())
overline(label->m_overline);
if (!label->m_underline.empty())
underline(label->m_underline);
background(label->m_background);
color(label->m_foreground);
if (label->m_padding > 0)
space(label->m_padding);
node(text, label->m_font, add_space);
if (label->m_padding > 0)
space(label->m_padding);
color_close(m_lazy && label->m_margin > 0);
background_close(m_lazy && label->m_margin > 0);
if (!label->m_underline.empty() || (label->m_margin > 0 && m_counters[syntaxtag::u] > 0))
underline_close(m_lazy && label->m_margin > 0);
if (!label->m_overline.empty() || (label->m_margin > 0 && m_counters[syntaxtag::o] > 0))
overline_close(m_lazy && label->m_margin > 0);
if (label->m_margin > 0)
space(label->m_margin);
}
TQFont KateAttribute::font(const TQFont& ref)
{
TQFont ret = ref;
if (itemSet(Weight))
ret.setWeight(weight());
if (itemSet(Italic))
ret.setItalic(italic());
if (itemSet(Underline))
ret.setUnderline(underline());
if (itemSet(Overline))
ret.setOverline(overline());
if (itemSet(StrikeOut))
ret.setStrikeOut(strikeOut());
return ret;
}
void print_packet (rip_header_ptr pointer, int num_entries){
underline ("# RIPv2 packet:");
if (pointer->command == 1)
printf (" request message with %d entries\n", num_entries);
else
printf (" response message with %d entries\n", num_entries);
if (num_entries > 0){
int i;
for (i=0; i<num_entries; i++){
printf(BOLD "Entry #%d" RESET, i+1);
print_entry (&(pointer->entry[i]));
}
}
}
void list_files( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo)
{
int i;
struct tm * ptm;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
printf( "\n File list %s\n", pDevInfo->Model);
printf( " ========= %s\n", underline( pDevInfo->Model));
printf("\n Handle\t Size Date Time Name\n");
for (i = 0; i < pHandles->cntHandles; i++) {
if (GetObjectInfo( hCam, pHandles->Handles[i], &pObjInfo)) {
camcli_error( "Could not get object info for handle %d",
pHandles->Handles[i]);
break;
}
if (pObjInfo->ObjectFormat != PTP_OFC_Association) {
ptm = localtime( &pObjInfo->CaptureDate);
printf( " % 4d\t% 9d %04d-%02d-%02d %02d:%02d %s\n",
pHandles->Handles[i], pObjInfo->ObjectCompressedSize,
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, pObjInfo->Filename);
}
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
static char *headline(char line, const char *buf, regmatch_t matches[],
size_t nmatch, size_t off)
{
const int i = 1;
char *result;
size_t len;
char *match;
len = matches[i].rm_eo - matches[i].rm_so;
match = ymalloc(len + 1);
memcpy(match, buf + matches[i].rm_so + off, len);
match[len] = '\0' ;
result = underline(line, match);
yfree(match);
return result;
}
void list_handles( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo)
{
int i;
CAMObjectHandlePtr pHandles = 0;
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
printf( "\n Handle list %s\n", pDevInfo->Model);
printf( " =========== %s\n", underline( pDevInfo->Model));
printf( "\n Handles Count= %d\n", pHandles->cntHandles);
for (i = 0; i < pHandles->cntHandles; i++)
printf( " % 4d\n", pHandles->Handles[i]);
if (pHandles)
free( pHandles);
return;
}
void show_info( CAMDeviceInfoPtr pDevInfo)
{
printf("\n Camera information %s\n", pDevInfo->Model);
printf(" ================== %s\n", underline(pDevInfo->Model));
printf(" Manufacturer: %s\n", pDevInfo->Manufacturer);
printf(" SerialNumber: %s\n", pDevInfo->SerialNumber);
printf(" DeviceVersion: %s\n", pDevInfo->DeviceVersion);
printf(" ExtensionID: 0x%04X\n", pDevInfo->VendorExtensionID);
printf(" ExtensionVersion: 0x%04X\n", pDevInfo->VendorExtensionVersion);
printf(" ExtDescription: %s\n", pDevInfo->VendorExtensionDesc);
if (pDevInfo->cntCaptureFormats == 0)
printf( " CaptureFormats: [unknown]\n");
else {
uint32_t ctr;
uint16_t fmt;
for (ctr = 0; ctr < pDevInfo->cntCaptureFormats; ctr++) {
fmt = pDevInfo->CaptureFormats[ctr];
printf( "%s0x%04X %s\n",
(ctr ? " " : " CaptureFormats: "),
fmt, GetCodeName( fmt, CAM_OBJECT_FORMAT));
}
}
if (pDevInfo->cntImageFormats == 0)
printf( " FileFormats: [unknown]\n");
else {
uint32_t ctr;
uint16_t fmt;
for (ctr = 0; ctr < pDevInfo->cntImageFormats; ctr++) {
fmt = pDevInfo->ImageFormats[ctr];
printf( "%s0x%04X %s\n",
(ctr ? " " : " FileFormats: "),
fmt, GetCodeName( fmt, CAM_OBJECT_FORMAT));
}
}
return;
}
void builder::node(string str, bool add_space) {
string::size_type n, m;
string s(str);
while (true) {
if (s.empty()) {
break;
} else if ((n = s.find("%{F-}")) == 0) {
color_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{F#")) == 0 && (m = s.find("}")) != string::npos) {
if (m - n - 4 == 2)
color_alpha(s.substr(n + 3, m - 3));
else
color(s.substr(n + 3, m - 3));
s.erase(n, m + 1);
} else if ((n = s.find("%{B-}")) == 0) {
background_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{B#")) == 0 && (m = s.find("}")) != string::npos) {
background(s.substr(n + 3, m - 3));
s.erase(n, m + 1);
} else if ((n = s.find("%{T-}")) == 0) {
font_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{T")) == 0 && (m = s.find("}")) != string::npos) {
font(std::atoi(s.substr(n + 3, m - 3).c_str()));
s.erase(n, m + 1);
} else if ((n = s.find("%{U-}")) == 0) {
line_color_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{U#")) == 0 && (m = s.find("}")) != string::npos) {
line_color(s.substr(n + 3, m - 3));
s.erase(n, m + 1);
} else if ((n = s.find("%{+u}")) == 0) {
underline();
s.erase(0, 5);
} else if ((n = s.find("%{+o}")) == 0) {
overline();
s.erase(0, 5);
} else if ((n = s.find("%{-u}")) == 0) {
underline_close(true);
s.erase(0, 5);
} else if ((n = s.find("%{-o}")) == 0) {
overline_close(true);
s.erase(0, 5);
} else if ((n = s.find("%{A}")) == 0) {
cmd_close(true);
s.erase(0, 4);
} else if ((n = s.find("%{")) == 0 && (m = s.find("}")) != string::npos) {
append(s.substr(n, m + 1));
s.erase(n, m + 1);
} else if ((n = s.find("%{")) > 0) {
append(s.substr(0, n));
s.erase(0, n);
} else
break;
}
if (!s.empty())
append(s);
if (add_space)
space();
}
void FlushGalley(OBJECT hd)
{ OBJECT dest; /* the target galley hd empties into */
OBJECT dest_index; /* the index of dest */
OBJECT inners; /* list of galleys and PRECEDES to flush */
OBJECT link, y; /* for scanning through the components of hd */
int dim; /* direction of galley */
CONSTRAINT dest_par_constr; /* the parallel size constraint on dest */
CONSTRAINT dest_perp_constr; /* the perpendicular size constraint on dest */
int pb, pf, f; /* candidate replacement sizes for dest */
OBJECT dest_encl; /* the VCAT or ACAT enclosing dest, if any */
int dest_side; /* if dest_encl != nilobj, side dest is on */
BOOLEAN need_adjust; /* TRUE as soon as dest_encl needs adjusting */
FULL_LENGTH dest_back, dest_fwd; /* the current size of dest_encl or dest */
FULL_LENGTH frame_size; /* the total constraint of dest_encl */
OBJECT prec_gap; /* the gap preceding dest if any else nilobj */
OBJECT prec_def; /* the component preceding dest, if any */
OBJECT succ_gap; /* the gap following dest if any else nilobj */
OBJECT succ_def; /* the component following dest, if any */
OBJECT stop_link; /* most recently seen gap link of hd */
FULL_LENGTH stop_back; /* back(dest_encl) incl all before stop_link */
FULL_LENGTH stop_fwd; /* fwd(dest_encl) incl. all before stop_link */
FULL_LENGTH stop_perp_back; /* back(dest_encl) in other direction */
FULL_LENGTH stop_perp_fwd; /* fwd(dest_encl) in other direction */
BOOLEAN prnt_flush; /* TRUE when the parent of hd needs a flush */
BOOLEAN target_is_internal; /* TRUE if flushing into an internal target */
BOOLEAN headers_seen; /* TRUE if a header is seen at all */
OBJECT zlink, z, tmp, prnt; int attach_status; BOOLEAN remove_target;
OBJECT why;
FULL_LENGTH perp_back, perp_fwd; /* current perp size of dest_encl */
debug1(DGF, D, "[ FlushGalley %s (hd)", SymName(actual(hd)));
prnt_flush = FALSE;
dim = gall_dir(hd);
RESUME:
assert( type(hd) == HEAD, "FlushGalley: type(hd) != HEAD!" );
debug1(DGF, D, " resuming FlushGalley %s, hd =", SymName(actual(hd)));
ifdebugcond(DGF, DD, actual(hd) == nilobj, DebugGalley(hd, nilobj, 4));
assert( Up(hd) != hd, "FlushGalley: resume found no parent to hd!" );
/*@@************************************************************************/
/* */
/* The first step is to examine the parent of galley hd to determine the */
/* status of the galley. If this is not suitable for flushing, we do */
/* what we can to change the status. If still no good, return; so if */
/* this code does not return, then the galley is ready to flush into a */
/* destination in the normal way, and the following variables are set: */
/* */
/* dest_index the parent of the galley and index of its destination */
/* dest the destination of the galley, a @Galley object */
/* */
/***************************************************************************/
Parent(dest_index, Up(hd));
switch( type(dest_index) )
{
case DEAD:
/* the galley has been killed off while this process was sleeping */
debug1(DGF, D, "] FlushGalley %s returning (DEAD)", SymName(actual(hd)));
return;
case UNATTACHED:
/* the galley is currently not attached to a destination */
attach_status = AttachGalley(hd, &inners, &y);
debug1(DGF, DD, " ex-AttachGalley inners: %s", DebugInnersNames(inners));
Parent(dest_index, Up(hd));
switch( attach_status )
{
case ATTACH_KILLED:
assert(inners==nilobj, "FlushGalley/ATTACH_KILLED: inners!=nilobj!");
debug1(DGF, D, "] FlushGalley %s returning (ATTACH_KILLED)",
SymName(actual(hd)));
debug1(DGF, D, " prnt_flush = %s", bool(prnt_flush));
return;
case ATTACH_INPUT:
ParentFlush(prnt_flush, dest_index, FALSE);
assert(inners==nilobj, "FlushGalley/ATTACH_INPUT: inners!=nilobj!");
debug1(DGF, D, "] FlushGalley %s returning (ATTACH_INPUT)",
SymName(actual(hd)));
return;
case ATTACH_NOTARGET:
ParentFlush(prnt_flush, dest_index, FALSE);
assert(inners==nilobj, "FlushGalley/ATTACH_NOTARG: inners!=nilobj!");
debug1(DGF, D, "] FlushGalley %s returning (ATTACH_NOTARGET)",
SymName(actual(hd)));
return;
case ATTACH_SUSPEND:
/* AttachGalley only returns inners here if they really need to */
/* be flushed; in particular the galley must be unsized before */
if( inners != nilobj )
{
debug0(DGF, DD, " calling FlushInners() from FlushGalley (a)");
FlushInners(inners, nilobj);
goto RESUME;
}
stop_link = nilobj;
goto SUSPEND; /* nb y will be set by AttachGalley in this case */
case ATTACH_NULL:
/* hd will have been linked to the unexpanded target in this case */
remove_target = (actual(actual(dest_index)) == whereto(hd));
if( force_gall(hd) )
{
/* if hd is a forcing galley, close all predecessors */
debug3(DGA, D, " forcing ATTACH_NULL case for %s into %s (%s)",
SymName(actual(hd)), SymName(whereto(hd)),
remove_target ? "remove_target" : "not remove_target");
Parent(prnt, Up(dest_index));
if( !non_blocking(dest_index) && remove_target )
{
/* ***
prnt_flush = TRUE;
*** */
prnt_flush = non_blocking(dest_index) = TRUE;
}
FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index),
whereto(hd));
}
else
{
debug3(DGA, D, " non-force ATTACH_NULL case for %s into %s (%s)",
SymName(actual(hd)), SymName(whereto(hd)),
remove_target ? "remove_target" : "not remove_target");
if( blocked(dest_index) && remove_target ) prnt_flush = TRUE;
}
DetachGalley(hd);
KillGalley(hd, TRUE);
if( inners != nilobj )
{
debug0(DGF, DD, " calling FlushInners() from FlushGalley (b)");
FlushInners(inners, nilobj);
}
else ParentFlush(prnt_flush, dest_index, remove_target);
debug0(DGF, D, "] FlushGalley returning ATTACH_NULL");
return;
case ATTACH_ACCEPT:
/* if hd is a forcing galley, or actual(dest_index) is */
/* @ForceGalley, then close all predecessors */
if( force_gall(hd) || actual(actual(dest_index)) == ForceGalleySym )
{ Parent(prnt, Up(dest_index));
debug1(DGA, D, " forcing ATTACH_ACCEPT case for %s",
SymName(actual(hd)));
/* debug0(DGA, DD, " force: prnt ="); */
/* ifdebug(DGA, DD, DebugObject(prnt)); */
/* debug1(DGA, D," calling FreeGalley from FlushGalley(%s)", */
/* SymName(actual(hd))); */
if( !non_blocking(dest_index) ) prnt_flush = TRUE; /* bug fix */
FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index),
whereto(hd));
/* debug0(DGA, DD, " force: after FreeGalley, prnt ="); */
/* ifdebug(DGA, DD, DebugObject(prnt)); */
}
else prnt_flush = prnt_flush || blocked(dest_index);
debug1(DGF, DD, " force: prnt_flush = %s", bool(prnt_flush));
if( inners != nilobj )
{
debug0(DGF, DD, " calling FlushInners() from FlushGalley (c)");
FlushInners(inners, nilobj);
}
goto RESUME;
default:
assert(FALSE, "FlushGalley: attach_status");
break;
}
break;
case RECEIVING:
if( actual(actual(dest_index)) == InputSym )
{ ParentFlush(prnt_flush, dest_index, FALSE);
debug1(DGF, D, "] FlushGalley %s retn, input", SymName(actual(hd)));
return;
}
break;
default:
assert1(FALSE, "FlushGalley: dest_index", Image(type(dest_index)));
break;
}
dest = actual(dest_index);
if( underline(dest) == UNDER_UNDEF ) underline(dest) = UNDER_OFF;
target_is_internal =
(dim==ROWM && !external_ver(dest)) || (dim==COLM && !external_hor(dest));
headers_seen = FALSE;
debug1(DGF, DD, " dest_index: %s", EchoObject(dest_index));
/*@@************************************************************************/
/* */
/* The second step is to examine the components of the galley one by one */
/* to determine if they can be promoted. Each component has the format */
/* */
/* { <index> } <object> */
/* */
/* and is always followed by a gap object (except the last component). */
/* An index indicates that the following object has some interesting */
/* feature, and it points to that feature inside the object. There are */
/* two possible actions for each component, in addition to accepting it: */
/* */
/* REJECT: The component does not fit, so detach the galley */
/* SUSPEND: The component is incomplete; go to sleep and wait */
/* */
/***************************************************************************/
stop_link = dest_encl = inners = nilobj;
need_adjust = FALSE;
/***************************************************************************/
/* */
/* Loop invariant */
/* */
/* The children of hd up to but not including Child(link) have been */
/* examined and pronounced to be promotable, if unbreakable gaps are */
/* ignored. When unbreakable gaps are taken into account, the most */
/* recent gap where a break is possible is at Child(stop_link), or */
/* nowhere if stop_link == nilobj. */
/* */
/* Case 1: target_is_internal == FALSE */
/* */
/* If this flag is FALSE, it means that the target of this galley is */
/* external. Consequently, there is no need to calculate sizes because */
/* there is no constraint on them. Also, a REJECT action is impossible */
/* so unbreakable gaps are no impediment. Variable dest_encl is nilobj. */
/* */
/* Case 2: target_is_internal == TRUE */
/* */
/* If this flag is TRUE, it means that the target of this galley is */
/* internal. Consequently, sizes need to be calculated, and unbreakable */
/* gaps need to be taken into account. Variable dest_encl may be not */
/* nilobj, in which case the following variables are defined: */
/* */
/* dest_encl the object enclosing dest (which must exist) */
/* prec_gap gap object preceding dest (which must exist) */
/* prec_def first definite object preceding dest (must exist) */
/* dest_back back(dest_encl) including effect of accepted compts */
/* dest_fwd fwd(dest_encl) including effect of accepted compts */
/* dest_side BACK or FWD, i.e. which side of the mark dest is on */
/* dest_par_constr the parallel size constraint on dest */
/* dest_perp_constr the perpendicular size constraint on dest */
/* frame_size size of frame enclosing dest_encl */
/* perp_back back(dest_encl) in other direction, incl accepteds */
/* perp_fwd fwd(dest_encl) in other direction, incl accepteds */
/* */
/* if dest_encl is nilobj, these variables are not defined. */
/* */
/* If stop_link is non-nilobj, then in the internal case dest_encl must */
/* be non-nilobj, and the following variables are defined: */
/* */
/* stop_back back(dest_encl) including all before stop_link */
/* stop_fwd fwd(dest_encl) including all before stop_link */
/* stop_perp_back back(dest_encl) in other direction */
/* stop_perp_fwd fwd(dest_encl) in other direction */
/* */
/* need_adjust is true if at least one definite component has been */
/* accepted for promotion and the destination is internal; hence, */
/* dest_encl is defined and its size needs to be adjusted. */
/* */
/* inners is the set of all PRECEDES and UNATTACHED indexes found. */
/* */
/***************************************************************************/
for( link = Down(hd); link != hd; link = NextDown(link) )
{
Child(y, link);
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
debug2(DGF, DD, " examining %s %s", Image(type(y)), EchoObject(y));
switch( type(y) )
{
case GAP_OBJ:
underline(y) = underline(dest);
prec_gap = y;
if( target_is_internal )
{
/* *** not necessarily true
assert( dest_encl != nilobj, "FlushGalley/GAP_OBJ: dest_encl!" );
*** */
if( dest_encl != nilobj && !nobreak(gap(prec_gap)) )
{
stop_link = link;
stop_back = dest_back;
stop_fwd = dest_fwd;
stop_perp_back = perp_back;
stop_perp_fwd = perp_fwd;
}
}
else stop_link = link;
if( !join(gap(y)) ) seen_nojoin(hd) = TRUE;
break;
case SCALE_IND:
case COVER_IND:
case EXPAND_IND:
case GALL_PREC:
case GALL_FOLL:
case GALL_FOLL_OR_PREC:
case GALL_TARG:
case CROSS_PREC:
case CROSS_FOLL:
case CROSS_FOLL_OR_PREC:
case CROSS_TARG:
case PAGE_LABEL_IND:
underline(y) = underline(dest);
break;
case PRECEDES:
case UNATTACHED:
if( inners == nilobj ) New(inners, ACAT);
Link(inners, y);
break;
case RECEIVING:
case RECEPTIVE:
goto SUSPEND;
case FOLLOWS:
Child(tmp, Down(y));
if( Up(tmp) == LastUp(tmp) )
{ link = PrevDown(link);
DisposeChild(NextDown(link));
break;
}
Parent(tmp, Up(tmp));
assert(type(tmp) == PRECEDES, "Flush: PRECEDES!");
switch( CheckComponentOrder(tmp, dest_index) )
{
case CLEAR: DeleteNode(tmp);
link = PrevDown(link);
DisposeChild(NextDown(link));
break;
case PROMOTE: break;
case BLOCK: goto SUSPEND;
case CLOSE: if( opt_components(hd) != nilobj )
{ DisposeObject(opt_components(hd));
opt_components(hd) = nilobj;
debug2(DOG, D, "FlushGalley(%s) de-optimizing %s",
"(CLOSE problem)", SymName(actual(hd)));
}
debug1(DGF, DD, " reject (a) %s", EchoObject(y));
goto REJECT;
}
break;
case BEGIN_HEADER:
case END_HEADER:
case SET_HEADER:
case CLEAR_HEADER:
/* do nothing except take note, until actually promoted out of here */
headers_seen = TRUE;
break;
case NULL_CLOS:
case PAGE_LABEL:
case WORD:
case QWORD:
case ONE_COL:
case ONE_ROW:
case WIDE:
case HIGH:
case HSHIFT:
case VSHIFT:
case HSCALE:
case VSCALE:
case HCOVER:
case VCOVER:
case HCONTRACT:
case VCONTRACT:
case HLIMITED:
case VLIMITED:
case HEXPAND:
case VEXPAND:
case START_HVSPAN:
case START_HSPAN:
case START_VSPAN:
case HSPAN:
case VSPAN:
case ROTATE:
case BACKGROUND:
case SCALE:
case KERN_SHRINK:
case INCGRAPHIC:
case SINCGRAPHIC:
case PLAIN_GRAPHIC:
case GRAPHIC:
case LINK_SOURCE:
case LINK_DEST:
case ACAT:
case HCAT:
case VCAT:
case ROW_THR:
case CLOSURE:
case CROSS:
case FORCE_CROSS:
underline(y) = underline(dest);
if( dim == ROWM )
{
/* make sure y is not joined to a target below (vertical case only) */
for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) )
{ Child(z, zlink);
switch( type(z) )
{
case RECEPTIVE:
case RECEIVING: y = z;
goto SUSPEND;
case GAP_OBJ: if( !join(gap(z)) ) zlink = PrevDown(hd);
break;
default: break;
}
}
/* try vertical hyphenation before anything else */
if( type(y) == HCAT ) VerticalHyphenate(y);
}
/* check size constraint */
if( target_is_internal )
{
/* initialise dest_encl etc if not done yet */
if( dest_encl == nilobj )
{ assert( UpDim(dest,1-dim) == UpDim(dest,dim), "FlushG: UpDims!" );
/* *** weird old code, trying for UpDim(dest, ROWM)?
Parent(dest_encl, NextDown(Up(dest)));
*** */
Parent(dest_encl, Up(dest));
debug4(DGF, DD, " flush dest = %s %s, dest_encl = %s %s",
Image(type(dest)), EchoObject(dest),
Image(type(dest_encl)), EchoObject(dest_encl));
assert( (dim==ROWM && type(dest_encl)==VCAT) ||
(dim==COLM && type(dest_encl)==ACAT),
"FlushGalley: dest != VCAT or ACAT!" );
SetNeighbours(Up(dest), FALSE, &prec_gap, &prec_def,
&succ_gap, &succ_def, &dest_side);
assert(prec_gap != nilobj || is_indefinite(type(y)),
"FlushGalley: prec_gap == nilobj && !is_indefinite(type(y))!" );
assert(succ_gap == nilobj, "FlushGalley: succ_gap != nilobj!" );
assert(dest_side == FWD || is_indefinite(type(y)),
"FlushGalley: dest_side != FWD || !is_indefinite(type(y))!");
dest_back = back(dest_encl, dim);
dest_fwd = fwd(dest_encl, dim);
perp_back = back(dest_encl, 1-dim);
perp_fwd = fwd(dest_encl, 1-dim);
Constrained(dest_encl, &dest_par_constr, dim, &why);
Constrained(dest_encl, &dest_perp_constr, 1-dim, &why);
debug1(DGF, DD, " setting dest_perp_constr = %s",
EchoConstraint(&dest_perp_constr));
frame_size = constrained(dest_par_constr) ? bfc(dest_par_constr) :0;
}
if( !is_indefinite(type(y)) )
{
ifdebugcond(DGF, DD, mode(gap(prec_gap)) == NO_MODE,
DebugGalley(hd, y, 4));
/* calculate parallel effect of adding y to dest */
f = dest_fwd + fwd(y, dim) - fwd(prec_def, dim) +
ActualGap(fwd(prec_def, dim), back(y, dim),
fwd(y, dim), &gap(prec_gap), frame_size,
dest_back + dest_fwd - fwd(prec_def, dim));
debug5(DGF, DD, " f = %s + %s - %s + %s (prec_gap %s)",
EchoLength(dest_fwd), EchoLength(fwd(y, dim)),
EchoLength(fwd(prec_def, dim)), EchoLength(
ActualGap(fwd(prec_def, dim), back(y, dim),
fwd(y, dim), &gap(prec_gap), frame_size,
dest_back + dest_fwd - fwd(prec_def, dim))
), EchoGap(&gap(prec_gap)));
debug3(DGF, DD, " b,f: %s,%s; dest_encl: %s",
EchoLength(dest_back), EchoLength(f),
EchoConstraint(&dest_par_constr));
/* check new size against parallel constraint */
if( (units(gap(prec_gap))==FRAME_UNIT && width(gap(prec_gap)) > FR)
|| !FitsConstraint(dest_back, f, dest_par_constr)
|| (opt_components(hd) != nilobj && opt_comps_permitted(hd)<=0)
)
{
if( opt_components(hd) != nilobj )
{ OBJECT z;
/* record the size of this just-completed target area for hd */
New(z, WIDE);
CopyConstraint(constraint(z), dest_par_constr);
Link(opt_constraints(hd), z);
ifdebug(DOG, D,
debug2(DOG, D, "FlushGalley(%s) adding constraint %s",
SymName(actual(hd)), EchoConstraint(&constraint(z)));
if( units(gap(prec_gap))==FRAME_UNIT &&
width(gap(prec_gap)) > FR )
{ debug1(DOG, D, " prec_gap = %s", EchoGap(&gap(prec_gap)));
}
if( !FitsConstraint(dest_back, f, dest_par_constr) )
{ debug3(DOG, D, " !FitsConstraint(%s, %s, %s)",
EchoLength(dest_back), EchoLength(f),
EchoConstraint(&dest_par_constr));
}
if( opt_comps_permitted(hd) <= 0 )
{ debug1(DOG, D, " opt_comps_permitted = %2d",
opt_comps_permitted(hd));
}
debug4(DOG, D, "prec_gap = %s; y = %s (%s,%s):",
EchoGap(&gap(prec_gap)), Image(type(y)),
EchoLength(back(y, dim)), EchoLength(fwd(y, dim)));
DebugObject(y);
)
/* refresh the number of components permitted into the next target */
if( opt_counts(hd) != nilobj && Down(opt_counts(hd)) != opt_counts(hd) )
{ Child(z, Down(opt_counts(hd)));
opt_comps_permitted(hd) += comp_count(z) - 1;
DisposeChild(Up(z));
}
else opt_comps_permitted(hd) = MAX_FILES; /* a large number */
debug1(DOG, D, " REJECT permitted = %2d", opt_comps_permitted(hd));
}
debug1(DGF, DD, " reject (b) %s", EchoObject(y));
goto REJECT;
}
/* calculate perpendicular effect of adding y to dest */
if( seen_nojoin(hd) )
{
pb = 0;
pf = find_max(perp_fwd, size(y, 1-dim));
}
else
{
pb = find_max(perp_back, back(y, 1-dim));
pf = find_max(perp_fwd, fwd(y, 1-dim));
}
/* check new size against perpendicular constraint */
if( !FitsConstraint(pb, pf, dest_perp_constr) )
{
if( opt_components(hd) != nilobj )
{ DisposeObject(opt_components(hd));
opt_components(hd) = nilobj;
debug1(DOG, D, "FlushGalley(%s) de-optimizing (perp problem)",
SymName(actual(hd)));
}
if( dim == ROWM )
{
Error(20, 3, "component too wide for available space",
WARN, &fpos(y));
debug6(DGF, DD, " %s,%s [%s,%s] too wide for %s, y = %s",
EchoLength(pb), EchoLength(pf),
EchoLength(back(y, 1-dim)), EchoLength(fwd(y, 1-dim)),
EchoConstraint(&dest_perp_constr), EchoObject(y));
}
debug1(DGF, DD, " reject (c) %s", EchoObject(y));
goto REJECT;
}
/* accept definite component */
dest_fwd = f; prec_def = y;
perp_back = pb; perp_fwd = pf;
need_adjust = TRUE;
if( opt_components(hd) != nilobj )
{ opt_comps_permitted(hd)--;
debug1(DOG, D, " ACCEPT permitted = %2d", opt_comps_permitted(hd));
}
}
/* accept indefinite component */
} /* end if( target_is_internal ) */
void getset_property( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
CAMPropertyDescPtr pProp = 0;
if (validate_property( pDevInfo, pOpts->property)) {
camcli_error( "The device does not support property 0x%04X", pOpts->property);
return;
}
if (GetPropertyDesc( hCam, pOpts->property, &pProp)) {
camcli_error( "Could not get device property description for 0x%04X", pOpts->property);
return;
}
printf( "\n Get/Set Property %s\n", pDevInfo->Model);
printf( " ================ %s\n", underline( pDevInfo->Model));
printf( " Property: 0x%04X\n", pProp->DevicePropertyCode);
printf( " Description: %s\n", GetPropertyName( pDevInfo, pOpts->property));
printf( " DataType: %s\n", GetCodeName( pProp->DataType, CAM_DATATYPE));
printf( " %sValue: ", (pOpts->value ? "Previous" : " Current"));
print_propval( pProp->DataType, pProp->cntCurrentValue, pProp->CurrentValue,
(pProp->FormFlag == CAM_PROP_EnumForm));
printf("\n");
if (pOpts->value) {
uint16_t ret;
CAMPropertyValuePtr pValue = 0;
ret = set_property( hCam, pProp->DevicePropertyCode,
pOpts->value, pProp->DataType);
if (ret == CAMERR_BADPARM)
camcli_error( "Unable to set property value for this datatype");
else
if (ret)
camcli_error( "Unable to set property value - rc= %X", ret);
else {
ret = GetPropertyValue( hCam, pProp->DevicePropertyCode,
pProp->DataType, &pValue);
if (ret == 0) {
printf( " NewValue: ");
print_propval( pValue->DataType, pValue->cntValue, pValue->Value,
(pProp->FormFlag == CAM_PROP_EnumForm));
printf("\n");
}
else
camcli_error( "Unable to get new property value - rc= %X", ret);
}
if (pValue)
free( pValue);
if (pProp)
free( pProp);
return;
}
printf( " DefaultValue: ");
print_propval( pProp->DataType, pProp->cntDefaultValue, pProp->DefaultValue,
(pProp->FormFlag == CAM_PROP_EnumForm));
printf("\n");
if (pProp->GetSet == CAM_PROP_ReadOnly)
printf( " Read/Write: read only\n");
else
printf( " Read/Write: read & write\n");
if (pProp->FormFlag == CAM_PROP_EnumForm) {
if (pProp->Form.Enum.cntSupportedValues) {
printf( " ValueFormat: enumeration\n");
printf( " AllowedValues: ");
print_propval( pProp->DataType, pProp->Form.Enum.cntSupportedValues,
pProp->Form.Enum.SupportedValues, 1);
printf( "\n");
}
}
else
if (pProp->FormFlag == CAM_PROP_RangeForm) {
printf( " ValueFormat: range\n");
printf( " AllowedValues: ");
print_propval( pProp->DataType, 1, pProp->Form.Range.MinimumValue, 1);
printf( " - ");
print_propval( pProp->DataType, 1, pProp->Form.Range.MaximumValue, 1);
printf( "; step size: ");
print_propval( pProp->DataType, 1, pProp->Form.Range.StepSize, 1);
printf( "\n");
}
else
if (pProp->FormFlag != CAM_PROP_None)
printf( " ValueFormat: %02X [not supported]\n", (uint8_t)pProp->FormFlag);
if (pProp)
free( pProp);
return;
}
int
do_article()
{
register char *s;
ART_POS artsize; /* size in bytes of article */
bool hide_this_line = FALSE; /* hidden header line? */
ART_LINE linenum; /* line # on page, 1 origin */
#ifdef ULSMARTS
bool under_lining = FALSE;
/* are we underlining a word? */
#endif
register char *bufptr = art_buf;
/* pointer to input buffer */
register int outpos; /* column position of output */
static char prompt_buf[64]; /* place to hold prompt */
bool notesfiles = FALSE; /* might there be notesfiles junk? */
char oldmode = mode;
#ifdef INNERSEARCH
register int outputok;
#endif
if (fstat(artfp->_file,&filestat))
/* get article file stats */
return DA_CLEAN;
if (filestat.st_mode & S_IFMT != S_IFREG)
return DA_NORM;
artsize = filestat.st_size;
/* from that get article size */
sprintf(prompt_buf,
"%%sEnd of article %ld (of %ld)--what next? [%%s]",
(long)art,(long)lastart); /* format prompt string */
prompt = prompt_buf;
int_count = 0; /* interrupt count is 0 */
firstpage = (topline < 0);
for (;;) { /* for each page */
assert(art == openart);
if (do_fseek) {
#ifdef ASYNC_PARSE
parse_maybe(art); /* make sure header is ours */
#endif
artpos = vrdary(artline);
if (artpos < 0)
artpos = -artpos; /* labs(), anyone? */
if (firstpage)
artpos = (ART_POS)0;
fseek(artfp,artpos,0);
if (artpos < htype[PAST_HEADER].ht_minpos)
in_header = SOME_LINE;
do_fseek = FALSE;
restart = Nullch;
}
if (firstpage) {
if (firstline) {
interp(art_buf, (sizeof art_buf), firstline);
#ifdef CLEAREOL
maybe_eol(); /* PWP */
#endif CLEAREOL
fputs(art_buf,stdout) FLUSH;
artopen(art); /* rewind article in case interp */
/* forced a header parse */
}
else {
ART_NUM i;
#ifdef CLEAREOL
maybe_eol(); /* PWP */
#endif CLEAREOL
printf("Article %ld",(long)art);
i = (((ART_NUM)toread[ng]) - 1 + was_read(art));
#ifdef DELAYMARK
if (i || dmcount) {
printf(" (%ld more",(long)i);
if (dmcount)
printf(" + %ld Marked to return)",(long)dmcount);
putchar(')');
}
#else
if (i)
printf(" (%ld more)",(long)i);
#endif
if (htype[NGS_LINE].ht_flags & HT_HIDE)
printf(" in %s", ngname);
fputs(":\n",stdout) FLUSH;
}
start_header(art);
forcelast = FALSE; /* we will have our day in court */
restart = Nullch;
artline = 0; /* start counting lines */
artpos = 0;
vwtary(artline,artpos); /* remember pos in file */
}
for (linenum=(firstpage?2:1);
in_header || (
#ifdef INNERSEARCH
innersearch ? innermore() :
#endif
linenum<(firstpage?initlines:(special?slines:LINES)) );
linenum++) { /* for each line on page */
if (int_count) { /* exit via interrupt? */
putchar('\n') FLUSH; /* get to left margin */
int_count = 0; /* reset interrupt count */
mode = oldmode;
return DA_NORM; /* skip out of loops */
}
if (restart) { /* did not finish last line? */
bufptr = restart; /* then start again here */
restart = Nullch; /* and reset the flag */
}
else { /* not a restart */
if (fgets(art_buf,LBUFLEN,artfp)==Nullch) {
/* if all done */
mode = oldmode;
return DA_NORM; /* skip out of loops */
}
bufptr = art_buf; /* so start at beginning */
art_buf[LBUFLEN-1] = '\0';
/* make sure string ends */
}
blinebeg = bufptr; /* remember where we began */
alinebeg = artpos; /* both in buffer and file */
if (in_header && bufptr == art_buf)
hide_this_line =
parseline(art_buf,do_hiding,hide_this_line);
else if (notesfiles && do_hiding &&
bufptr == art_buf && *art_buf == '#' &&
isupper(art_buf[1]) && art_buf[2] == ':' ) {
fgets(art_buf,sizeof(art_buf),artfp);
if (index(art_buf,'!') != Nullch)
fgets(art_buf,sizeof(art_buf),artfp);
htype[PAST_HEADER].ht_minpos = ftell(artfp);
/* exclude notesfiles droppings */
hide_this_line = TRUE; /* and do not print either */
notesfiles = FALSE;
}
#ifdef CUSTOMLINES
if (hideline && bufptr == art_buf &&
execute(&hide_compex,art_buf) )
hide_this_line = TRUE;
#endif
if (in_header && htype[in_header].ht_flags & HT_MAGIC) {
if (in_header == NGS_LINE) {
hide_this_line = (index(art_buf,',') == Nullch);
}
else if (in_header == EXPIR_LINE) {
if (!(htype[EXPIR_LINE].ht_flags & HT_HIDE))
hide_this_line = (strlen(art_buf) < 10);
}
}
if (in_header == SUBJ_LINE &&
htype[SUBJ_LINE].ht_flags & HT_MAGIC) {
/* is this the subject? */
int length;
length = strlen(art_buf)-1;
artline++;
art_buf[length] = '\0'; /* wipe out newline */
#ifdef NOFIREWORKS
no_ulfire();
#endif
notesfiles =
(instr(&art_buf[length-10]," - (nf") != Nullch);
if (oldsubject) {
length += 7;
fputs("(SAME) ",stdout);
oldsubject = FALSE;
}
if (length+UG > COLS) { /* rarely true */
linenum++;
vwtary(artline,vrdary(artline-1)+COLS);
artline++;
}
s = art_buf + 8;
*s++ = '\0'; /* make into 2 strings */
#ifdef CLEAREOL
maybe_eol(); /* PWP */
#endif CLEAREOL
fputs(art_buf,stdout) FLUSH;
/* print up through : */
if (!UG)
putchar(' ');
underprint(s); /* print subject underlined */
putchar('\n') FLUSH; /* and finish the line */
}
else if (hide_this_line && do_hiding) {
/* do not print line? */
linenum--; /* compensate for linenum++ */
if (!in_header)
hide_this_line = FALSE;
}
else { /* just a normal line */
if (highlight==artline) { /* this line to be highlit? */
if (marking == STANDOUT) {
#ifdef NOFIREWORKS
if (erase_screen)
no_sofire();
#endif
standout();
}
else {
#ifdef NOFIREWORKS
if (erase_screen)
no_ulfire();
#endif
underline();
}
if (*bufptr == '\n')
putchar(' ');
}
#ifdef INNERSEARCH
outputok = !hide_everything;
/* get it into register, hopefully */
#endif
#ifdef CLEAREOL
#ifdef INNERSEARCH
if (outputok)
#endif
maybe_eol(); /* PWP */
#endif CLEAREOL
#ifdef CUSTOMLINES
if (pagestop && bufptr == art_buf &&
execute(&page_compex,art_buf) )
linenum = 32700;
#endif
for (outpos = 0; outpos < COLS; ) {
/* while line has room */
if (*bufptr >= ' ') { /* normal char? */
#ifdef ULSMARTS
if (*bufptr == '_') {
if (bufptr[1] == '\b') {
if (!under_lining && highlight!=artline
#ifdef INNERSEARCH
&& outputok
#endif
) {
under_lining++;
if (UG) {
if (bufptr != buf &&
bufptr[-1] == ' ') {
outpos--;
backspace();
}
}
underline();
}
bufptr += 2;
}
}
else {
if (under_lining) {
under_lining = 0;
un_underline();
if (UG) {
if (*bufptr == ' ')
goto skip_put;
outpos++;
}
}
}
#endif
#ifdef INNERSEARCH
if (outputok)
#endif
{
#ifdef ROTATION
if (rotate && !in_header
&& isalpha(*bufptr)) {
if ((*bufptr & 31) <= 13)
putchar(*bufptr+13);
else
putchar(*bufptr-13);
}
else
#endif
putchar(*bufptr);
}
if (*UC && ((highlight==artline && marking == 1)
#ifdef ULSMARTS
|| under_lining
#endif
)) {
backspace();
underchar();
}
skip_put:
bufptr++;
outpos++;
}
else if (*bufptr == '\n' || !*bufptr) {
/* newline? */
#ifdef ULSMARTS
if (under_lining) {
under_lining = 0;
un_underline();
}
#endif
#ifdef DEBUGGING
if (debug & DEB_INNERSRCH && outpos < COLS - 6) {
standout();
printf("%4d",artline);
un_standout();
}
#endif
#ifdef INNERSEARCH
if (outputok)
#endif
putchar('\n') FLUSH;
restart = 0;
outpos = 1000; /* signal normal \n */
}
else if (*bufptr == '\t') { /* tab? */
#ifdef INNERSEARCH
if (outputok)
#endif
putchar(*bufptr);
bufptr++;
outpos += 8 - outpos % 8;
}
else if (*bufptr == '\f') { /* form feed? */
#ifdef INNERSEARCH
if (outputok)
#endif
fputs("^L",stdout);
if (bufptr == blinebeg && highlight != artline)
linenum = 32700;
/* how is that for a magic number? */
bufptr++;
outpos += 2;
}
else { /* other control char */
#ifdef INNERSEARCH
if (outputok)
#endif
{
putchar('^');
if (highlight == artline && *UC && marking == 1) {
backspace();
underchar();
putchar(*bufptr+64);
backspace();
underchar();
}
else
putchar(*bufptr+64);
}
bufptr++;
outpos += 2;
}
} /* end of column loop */
if (outpos < 1000) {/* did line overflow? */
restart = bufptr;
/* restart here next time */
if (AM) { /* automatic margins on tty? */
if (!XN && *bufptr == '\n')
/* need we simulate XN? */
restart = 0;
/* skip the newline */
}
else { /* cursor just hangs there */
#ifdef INNERSEARCH
if (outputok)
#endif
putchar('\n') FLUSH;
/* so move it down ourselves */
if (*bufptr == '\n')
restart = 0;
/* simulate XN if need be */
}
#ifdef CLEAREOL
/* #ifdef INNERSEARCH
if (outputok)
#endif
maybe_eol(); */ /* PWP *//* comment this out for now
until I am sure it is
needed*/
#endif CLEAREOL
}
/* handle normal end of output line formalities */
if (highlight == artline) {
/* were we highlighting line? */
if (marking == STANDOUT)
un_standout();
else
un_underline();
highlight = -1; /* no more we are */
}
artline++; /* count the line just printed */
if (artline - LINES + 1 > topline)
/* did we just scroll top line off? */
topline = artline - LINES + 1;
/* then recompute top line # */
}
/* determine actual position in file */
if (restart) /* stranded somewhere in the buffer? */
artpos += restart - blinebeg;
/* just calculate position */
else /* no, ftell will do */
artpos = ftell(artfp);
/* so do ftell */
vwtary(artline,artpos); /* remember pos in file */
} /* end of line loop */
#ifdef INNERSEARCH
innersearch = 0;
if (hide_everything) {
hide_everything = FALSE;
*buf = Ctl('l');
goto fake_command;
}
#endif
if (linenum >= 32700)/* did last line have formfeed? */
vwtary(artline-1,-vrdary(artline-1));
/* remember by negating pos in file */
special = FALSE; /* end of page, so reset page length */
firstpage = FALSE; /* and say it is not 1st time thru */
/* extra loop bombout */
if (artpos == artsize) {/* did we just now reach EOF? */
mode = oldmode;
return DA_NORM; /* avoid --MORE--(100%) */
}
/* not done with this article, so pretend we are a pager */
reask_pager:
unflush_output(); /* disable any ^O in effect */
standout(); /* enter standout mode */
printf("--MORE--(%ld%%)",(long)(artpos*100/artsize));
un_standout(); /* leave standout mode */
fflush(stdout);
/* reinp_pager: /* unused, commented for lint */
eat_typeahead();
#ifdef DEBUGGING
if (debug & DEB_CHECKPOINTING) {
printf("(%d %d %d)",checkcount,linenum,artline);
fflush(stdout);
}
#endif
if (checkcount >= docheckwhen &&
linenum == LINES &&
(artline > 40 || checkcount >= docheckwhen+10) ) {
/* while he is reading a whole page */
/* in an article he is interested in */
checkcount = 0;
checkpoint_rc(); /* update .newsrc */
}
collect_subjects(); /* loads subject cache until */
/* input is pending */
mode = 'p';
getcmd(buf);
if (errno) {
if (LINES < 100 && !int_count)
*buf = '\f';/* on CONT fake up refresh */
else {
*buf = 'q'; /* on INTR or paper just quit */
}
}
carriage_return();
#ifndef CLEAREOL
erase_eol(); /* and erase the prompt */
#else
if (erase_screen && can_home_clear) /* PWP was here */
clear_rest();
else
erase_eol(); /* and erase the prompt */
#endif CLEAREOL
fflush(stdout);
fake_command: /* used by innersearch */
/* parse and process pager command */
switch (page_switch()) {
case PS_ASK: /* reprompt "--MORE--..." */
goto reask_pager;
case PS_RAISE: /* reparse on article level */
mode = oldmode;
return DA_RAISE;
case PS_TOEND: /* fast pager loop exit */
mode = oldmode;
return DA_TOEND;
case PS_NORM: /* display more article */
break;
}
} /* end of page loop */
}
std::string underline(const std::string& text, unsigned length) {
return underline(text.substr(0, length)) + text.substr(length);
}
void get_files( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
int ret;
int fName;
char *pName;
uint32_t *pHandle;
uint32_t *pEnd;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
FNSTRUCT fns;
char path[260];
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
fName = parse_filename( pOpts->value, &fns);
if (fName)
pName = path;
else
pName = 0;
if (!validate_range( pHandles, pOpts, &pHandle, &pEnd)) {
if (pHandles)
free( pHandles);
return;
}
if (pOpts->flags & OPT_THUMBNAIL) {
printf ( "\n Save thumbnails %s\n", pDevInfo->Model);
printf ( " =============== %s\n", underline( pDevInfo->Model));
}
else {
printf ( "\n Save files %s\n", pDevInfo->Model);
printf ( " ========== %s\n", underline( pDevInfo->Model));
}
for (; pHandle <= pEnd; pHandle++) {
ret = GetObjectInfo( hCam, *pHandle, &pObjInfo);
if (ret) {
camcli_error( "Could not get info for handle %d", *pHandle);
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
continue;
}
if (pObjInfo->ObjectFormat == PTP_OFC_Association)
printf( " Handle %d is not a file - skipping...\n", *pHandle);
else {
if (fName)
make_filename( pName, pObjInfo->Filename, &fns);
ret = os2_get_file( hCam, pObjInfo, *pHandle, pName,
(pOpts->flags & OPT_REPLACE),
(pOpts->flags & OPT_THUMBNAIL));
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
}
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
MenuExample::MenuExample( QWidget *parent, const char *name )
: QWidget( parent, name )
{
QPixmap p1( p1_xpm );
QPixmap p2( p2_xpm );
QPixmap p3( p3_xpm );
QPopupMenu *print = new QPopupMenu( this );
CHECK_PTR( print );
print->insertTearOffHandle();
print->insertItem( "&Print to printer", this, SLOT(printer()) );
print->insertItem( "Print to &file", this, SLOT(file()) );
print->insertItem( "Print to fa&x", this, SLOT(fax()) );
print->insertSeparator();
print->insertItem( "Printer &Setup", this, SLOT(printerSetup()) );
QPopupMenu *file = new QPopupMenu( this );
CHECK_PTR( file );
file->insertItem( p1, "&Open", this, SLOT(open()), CTRL+Key_O );
file->insertItem( p2, "&New", this, SLOT(news()), CTRL+Key_N );
file->insertItem( p3, "&Save", this, SLOT(save()), CTRL+Key_S );
file->insertItem( "&Close", this, SLOT(closeDoc()), CTRL+Key_W );
file->insertSeparator();
file->insertItem( "&Print", print, CTRL+Key_P );
file->insertSeparator();
file->insertItem( "E&xit", qApp, SLOT(quit()), CTRL+Key_Q );
QPopupMenu *edit = new QPopupMenu( this );
CHECK_PTR( edit );
int undoID = edit->insertItem( "&Undo", this, SLOT(undo()) );
int redoID = edit->insertItem( "&Redo", this, SLOT(redo()) );
edit->setItemEnabled( undoID, FALSE );
edit->setItemEnabled( redoID, FALSE );
QPopupMenu* options = new QPopupMenu( this );
CHECK_PTR( options );
options->insertTearOffHandle();
options->setCaption("Options");
options->insertItem( "&Normal Font", this, SLOT(normal()) );
options->insertSeparator();
options->polish(); // adjust system settings
QFont f = options->font();
f.setBold( TRUE );
boldID = options->insertItem( new MyMenuItem( "Bold", f ) );
options->setAccel( CTRL+Key_B, boldID );
options->connectItem( boldID, this, SLOT(bold()) );
f = font();
f.setUnderline( TRUE );
underlineID = options->insertItem( new MyMenuItem( "Underline", f ) );
options->setAccel( CTRL+Key_U, underlineID );
options->connectItem( underlineID, this, SLOT(underline()) );
isBold = FALSE;
isUnderline = FALSE;
options->setCheckable( TRUE );
QPopupMenu *help = new QPopupMenu( this );
CHECK_PTR( help );
help->insertItem( "&About", this, SLOT(about()), CTRL+Key_H );
help->insertItem( "About &Qt", this, SLOT(aboutQt()) );
menu = new QMenuBar( this );
CHECK_PTR( menu );
menu->insertItem( "&File", file );
menu->insertItem( "&Edit", edit );
menu->insertItem( "&Options", options );
menu->insertSeparator();
menu->insertItem( "&Help", help );
menu->setSeparator( QMenuBar::InWindowsStyle );
label = new QLabel( this );
CHECK_PTR( label );
label->setGeometry( 20, rect().center().y()-20, width()-40, 40 );
label->setFrameStyle( QFrame::Box | QFrame::Raised );
label->setLineWidth( 1 );
label->setAlignment( AlignCenter );
connect( this, SIGNAL(explain(const QString&)),
label, SLOT(setText(const QString&)) );
setMinimumSize( 100, 80 );
}
void show_handle_info( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
uint32_t *pHandle;
uint32_t *pEnd;
struct tm *ptm;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
if (!validate_range( pHandles, pOpts, &pHandle, &pEnd)) {
if (pHandles)
free( pHandles);
return;
}
printf ( "\n File information %s\n", pDevInfo->Model);
printf ( " ================ %s\n", underline( pDevInfo->Model));
for (; pHandle <= pEnd; pHandle++) {
if (GetObjectInfo( hCam, *pHandle, &pObjInfo)) {
camcli_error( "Could not get object info for handle %d", *pHandle);
continue;
}
printf ( " Handle: %04d\n", *pHandle);
printf ( " Filename: %s\n", (pObjInfo->Filename ? pObjInfo->Filename : "[none]"));
if (pObjInfo->CaptureDate == 0)
ptm = 0;
else
ptm = localtime( &pObjInfo->CaptureDate);
if (!ptm)
printf ( " CaptureDate: [unknown]\n");
else
printf ( " CaptureDate: %04d-%02d-%02d %02d:%02d:%02d\n",
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
if (pObjInfo->ModificationDate == 0)
ptm = 0;
else
ptm = localtime( &pObjInfo->ModificationDate);
if (!ptm)
printf ( " ModificationDate: [unknown]\n");
else
printf ( " ModificationDate: %04d-%02d-%02d %02d:%02d:%02d\n",
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
printf ( " Keywords: %s\n", (pObjInfo->Keywords ? pObjInfo->Keywords : "[none]"));
printf ( " ProtectionStatus: 0x%04X\t%s\n", pObjInfo->ProtectionStatus, GetCodeName( pObjInfo->ProtectionStatus, CAM_PROTECTION));
printf ( "ObjectCompressedSize: %d\n", pObjInfo->ObjectCompressedSize);
printf ( " ObjectFormat: 0x%04X\t%s\n", pObjInfo->ObjectFormat, GetCodeName( pObjInfo->ObjectFormat, CAM_OBJECT_FORMAT));
printf ( " ImagePixWidth: %d\n", pObjInfo->ImagePixWidth);
printf ( " ImagePixHeight: %d\n", pObjInfo->ImagePixHeight);
printf ( " ImageBitDepth: %d\n", pObjInfo->ImageBitDepth);
printf ( " ThumbCompressedSize: %d\n", pObjInfo->ThumbCompressedSize);
printf ( " ThumbFormat: 0x%04X\t%s\n", pObjInfo->ThumbFormat, GetCodeName( pObjInfo->ThumbFormat, CAM_OBJECT_FORMAT));
printf ( " ThumbPixWidth: %d\n", pObjInfo->ThumbPixWidth);
printf ( " ThumbPixHeight: %d\n", pObjInfo->ThumbPixHeight);
printf ( " ParentObject: %04d\n", pObjInfo->ParentObject);
printf ( " AssociationType: 0x%04X\t%s\n", pObjInfo->AssociationType, GetCodeName( pObjInfo->AssociationType, CAM_ASSOCIATION));
printf ( " AssociationDesc: 0x%04X\n", pObjInfo->AssociationDesc);
printf ( " SequenceNumber: 0x%04X\n", pObjInfo->SequenceNumber);
printf ( " StorageID: 0x%04X\n\n", pObjInfo->StorageID);
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
int AttachGalley(OBJECT hd, OBJECT *inners, OBJECT *suspend_pt)
{ OBJECT hd_index; /* the index of hd in the enclosing galley */
OBJECT hd_inners; /* inner galleys of hd, if unsized */
OBJECT dest; /* the target @Galley hd empties into */
OBJECT dest_index; /* the index of dest */
OBJECT target; /* the target indefinite containing dest */
OBJECT target_index; /* the index of target */
OBJECT target_galley; /* the body of target, made into a galley */
OBJECT tg_inners; /* inner galleys of target_galley */
BOOLEAN need_precedes = FALSE;/* true if destination lies before galley */
OBJECT recs; /* list of recursive definite objects */
OBJECT link, y = nilobj; /* for scanning through the components of hd */
CONSTRAINT c; /* temporary variable holding a constraint */
OBJECT env, n1, tmp, zlink, z, sym; /* placeholders and temporaries */
BOOLEAN was_sized; /* true if sized(hd) initially */
int dim; /* the galley direction */
FULL_LENGTH perp_back, perp_fwd;
OBJECT why, junk;
debug2(DGA, D, "[ AttachGalley(Galley %s into %s)",
SymName(actual(hd)), SymName(whereto(hd)));
ifdebug(DGA, DD, DebugGalley(hd, nilobj, 4));
assert( Up(hd) != hd, "AttachGalley: no index!" );
Parent(hd_index, Up(hd));
assert( type(hd_index) == UNATTACHED, "AttachGalley: not UNATTACHED!" );
hd_inners = tg_inners = nilobj;
was_sized = sized(hd);
dim = gall_dir(hd);
for(;;)
{
/*************************************************************************/
/* */
/* Search for a destination for hd. If hd is unsized, search for */
/* inner galleys preceding it first of all, then for receptive objects */
/* following it, possibly in inner galleys. If no luck, exit. */
/* If hd is sized, search only for receptive objects in the current */
/* galley below the current spot, and fail if cannot find any. */
/* */
/*************************************************************************/
sym = whereto(hd);
if( sized(hd) )
{
/* sized galley case: search on from current spot */
target_index = SearchGalley(Up(hd_index), sym, TRUE, FALSE, TRUE, TRUE);
if( target_index == nilobj )
{
/* search failed to find any new target, so kill the galley */
for( link = Down(hd); link != hd; link = NextDown(link) )
{ Child(y, link);
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
if( is_definite(type(y)) ) break;
}
if( link != hd )
Error(19, 1, "galley %s deleted from here (no target)",
WARN, &fpos(y), SymName(actual(hd)));
if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj;
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners=nilobj;
KillGalley(hd, FALSE);
*inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_KILLED");
return ATTACH_KILLED;
}
else if( actual(actual(target_index)) == InputSym )
{
/* search found input object, so suspend on that */
DeleteNode(hd_index);
Link(target_index, hd);
*inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_INPUT");
return ATTACH_INPUT;
}
}
else /* unsized galley, either backwards or normal */
{
if( foll_or_prec(hd) == GALL_PREC )
{ target_index= SearchGalley(Up(hd_index), sym, FALSE, TRUE,TRUE,FALSE);
need_precedes = FALSE;
}
else
{ target_index = SearchGalley(Up(hd_index), sym, FALSE,TRUE,FALSE,FALSE);
need_precedes = (target_index != nilobj);
if( target_index == nilobj )
target_index = SearchGalley(Up(hd_index), sym, TRUE,TRUE,TRUE,FALSE);
}
/* if no luck, exit without error */
if( target_index == nilobj )
{ *inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_NOTARGET");
return ATTACH_NOTARGET;
}
}
assert( type(target_index) == RECEPTIVE, "AttachGalley: target_index!" );
target = actual(target_index);
assert( type(target) == CLOSURE, "AttachGalley: target!" );
/* set target_galley to the expanded value of target */
debug1(DYY, D, "[ EnterErrorBlock(FALSE) (expanding target %s)",
SymName(actual(target)));
EnterErrorBlock(FALSE);
New(target_galley, HEAD);
force_gall(target_galley) = FALSE;
enclose_obj(target_galley) = limiter(target_galley) = nilobj;
ClearHeaders(target_galley);
opt_components(target_galley) = opt_constraints(target_galley) = nilobj;
gall_dir(target_galley) = external_hor(target) ? COLM : ROWM;
FposCopy(fpos(target_galley), fpos(target));
actual(target_galley) = actual(target);
whereto(target_galley) = ready_galls(target_galley) = nilobj;
foll_or_prec(target_galley) = GALL_FOLL;
must_expand(target_galley) = FALSE;
sized(target_galley) = FALSE;
/* get perpendicular constraint (none if horizontal galley) */
if( dim == ROWM )
{
Constrained(target, &c, 1-dim, &junk);
if( !constrained(c) )
Error(19, 2, "receptive symbol %s has unconstrained width",
FATAL, &fpos(target), SymName(actual(target)));
debug2(DSC, DD, "Constrained( %s, 1-dim ) = %s",
EchoObject(target), EchoConstraint(&c));
if( !FitsConstraint(0, 0, c) )
{ debug0(DGA, D, " reject: target_galley horizontal constraint is -1");
y = nilobj;
goto REJECT;
}
}
else /* actually unused */
SetConstraint(c, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH);
debug1(DGA, DDD, " expanding %s", EchoObject(target));
tmp = CopyObject(target, no_fpos);
Link(target_galley, tmp);
env = DetachEnv(tmp);
debug4(DGM, D, " external_ver(%s) = %s, external_hor(%s) = %s",
SymName(actual(target)), bool(external_ver(target)),
SymName(actual(target)), bool(external_hor(target)));
SizeGalley(target_galley, env,
external_ver(target) || external_hor(target),
threaded(target), non_blocking(target_index),
trigger_externs(target_index), &save_style(target),
&c, whereto(hd), &dest_index, &recs, &tg_inners,
enclose_obj(hd) != nilobj ? CopyObject(enclose_obj(hd), no_fpos):nilobj);
debug1(DGA, DD, " SizeGalley tg_inners: %s", DebugInnersNames(tg_inners));
if( recs != nilobj ) ExpandRecursives(recs);
dest = actual(dest_index);
if( underline(dest) == UNDER_UNDEF ) underline(dest) = UNDER_OFF;
/* verify that hd satisfies any horizontal constraint on dest */
if( dim == ROWM )
{
debug1(DGA, DDD, " checking hor fit of hd in %s",SymName(actual(dest)));
Constrained(dest, &c, 1-dim, &junk);
debug3(DSC, DD, "Constrained( %s, %s ) = %s",
EchoObject(dest), dimen(1-dim), EchoConstraint(&c));
assert( constrained(c), "AttachGalley: dest unconstrained!" );
if( !FitsConstraint(0, 0, c) )
{ debug0(DGA, D, " reject: hd horizontal constraint is -1");
y = nilobj;
goto REJECT;
}
}
/* manifest and size the galley if not done yet */
if( !sized(hd) )
{
debug2(DYY, D, "[ EnterErrorBlock(TRUE) (sizing galley %s into %s)",
SymName(actual(hd)), SymName(whereto(hd)));
EnterErrorBlock(TRUE);
n1 = nilobj;
Child(y, Down(hd));
env = DetachEnv(y);
/*** threaded() only defined in ROWM case
SizeGalley(hd, env, TRUE, threaded(dest), non_blocking(target_index),
TRUE, &save_style(dest), &c, nilobj, &n1, &recs, &hd_inners);
*** */
SizeGalley(hd, env, TRUE, dim == ROWM ? threaded(dest) : FALSE,
non_blocking(target_index), TRUE, &save_style(dest), &c, nilobj,
&n1, &recs, &hd_inners, nilobj);
debug1(DGA,DD," SizeGalley hd_inners: %s", DebugInnersNames(hd_inners));
if( recs != nilobj ) ExpandRecursives(recs);
if( need_precedes ) /* need an ordering constraint */
{ OBJECT index1, index2;
New(index1, PRECEDES);
New(index2, FOLLOWS);
blocked(index2) = FALSE;
tmp = MakeWord(WORD, STR_EMPTY, no_fpos);
Link(index1, tmp); Link(index2, tmp);
Link(Up(hd_index), index1);
Link(Down(hd), index2);
debug0(DGA, D, " inserting PRECEDES and FOLLOWS");
}
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (finished sizing galley)");
}
if( dim == ROWM )
{ if( !FitsConstraint(back(hd, 1-dim), fwd(hd, 1-dim), c) )
{ debug3(DGA, D, " reject: hd %s,%s does not fit target_galley %s",
EchoLength(back(hd, 1-dim)), EchoLength(fwd(hd, 1-dim)),
EchoConstraint(&c));
Error(19, 3, "too little horizontal space for galley %s at %s",
WARN, &fpos(hd), SymName(actual(hd)), SymName(actual(dest)));
goto REJECT;
}
}
/* check status of first component of hd */
debug0(DGA, DDD, " now ready to attach; hd =");
ifdebug(DGA, DDD, DebugObject(hd));
for( link = Down(hd); link != hd; link = NextDown(link) )
{
Child(y, link);
debug1(DGA, DDD, " examining %s", EchoIndex(y));
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
switch( type(y) )
{
case EXPAND_IND:
case SCALE_IND:
case COVER_IND:
case GALL_PREC:
case GALL_FOLL:
case GALL_FOLL_OR_PREC:
case GALL_TARG:
case CROSS_PREC:
case CROSS_FOLL:
case CROSS_FOLL_OR_PREC:
case CROSS_TARG:
case PAGE_LABEL_IND:
break;
case PRECEDES:
case UNATTACHED:
if( was_sized )
{ /* SizeGalley was not called, so hd_inners was not set by it */
if( hd_inners == nilobj ) New(hd_inners, ACAT);
Link(hd_inners, y);
}
break;
case RECEPTIVE:
goto SUSPEND;
case RECEIVING:
goto SUSPEND;
case FOLLOWS:
Child(tmp, Down(y));
if( Up(tmp) == LastUp(tmp) )
{ link = pred(link, CHILD);
debug0(DGA, DD, " disposing FOLLOWS");
DisposeChild(NextDown(link));
break;
}
Parent(tmp, Up(tmp));
assert(type(tmp) == PRECEDES, "Attach: PRECEDES!");
switch( CheckComponentOrder(tmp, target_index) )
{
case CLEAR: DeleteNode(tmp);
link = pred(link, CHILD);
DisposeChild(NextDown(link));
break;
case PROMOTE: break;
case BLOCK: debug0(DGA, DD, "CheckContraint: BLOCK");
goto SUSPEND;
case CLOSE: debug0(DGA, D, " reject: CheckContraint");
goto REJECT;
}
break;
case GAP_OBJ:
underline(y) = underline(dest);
if( !join(gap(y)) ) seen_nojoin(hd) = TRUE;
break;
case BEGIN_HEADER:
case END_HEADER:
case SET_HEADER:
case CLEAR_HEADER:
/* do nothing until actually promoted out of here */
underline(y) = underline(dest);
break;
case CLOSURE:
case CROSS:
case FORCE_CROSS:
case NULL_CLOS:
case PAGE_LABEL:
underline(y) = underline(dest);
break;
case WORD:
case QWORD:
case ONE_COL:
case ONE_ROW:
case WIDE:
case HIGH:
case HSHIFT:
case VSHIFT:
case HMIRROR:
case VMIRROR:
case HSCALE:
case VSCALE:
case HCOVER:
case VCOVER:
case HCONTRACT:
case VCONTRACT:
case HLIMITED:
case VLIMITED:
case HEXPAND:
case VEXPAND:
case START_HVSPAN:
case START_HSPAN:
case START_VSPAN:
case HSPAN:
case VSPAN:
case ROTATE:
case BACKGROUND:
case SCALE:
case KERN_SHRINK:
case INCGRAPHIC:
case SINCGRAPHIC:
case PLAIN_GRAPHIC:
case GRAPHIC:
case LINK_SOURCE:
case LINK_DEST:
case LINK_DEST_NULL:
case LINK_URL:
case ACAT:
case HCAT:
case VCAT:
case ROW_THR:
case COL_THR:
underline(y) = underline(dest);
if( dim == ROWM )
{
/* make sure y is not joined to a target below (vertical only) */
for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) )
{ Child(z, zlink);
switch( type(z) )
{
case RECEPTIVE:
if( non_blocking(z) )
{ zlink = PrevDown(zlink);
DeleteNode(z);
}
else
{ y = z;
goto SUSPEND;
}
break;
case RECEIVING:
if( non_blocking(z) )
{ zlink = PrevDown(zlink);
while( Down(z) != z )
{ Child(tmp, Down(y));
if( opt_components(tmp) != nilobj )
{ DisposeObject(opt_components(tmp));
opt_components(tmp) = nilobj;
debug3(DOG, D, "AttachGalley(%s) de-optimizing %s %s",
SymName(actual(hd)), SymName(actual(tmp)), "(join)");
}
DetachGalley(tmp);
KillGalley(tmp, FALSE);
}
DeleteNode(z);
}
else
{ y = z;
goto SUSPEND;
}
break;
case GAP_OBJ:
if( !join(gap(z)) ) zlink = PrevDown(hd);
break;
default: break;
}
}
/* if HCAT, try vertical hyphenation (vertical galleys only) */
if( type(y) == HCAT ) VerticalHyphenate(y);
}
/* check availability of parallel space for the first component */
why = nilobj;
Constrained(dest, &c, dim, &why);
debug3(DGF, DD, " dest parallel Constrained(%s, %s) = %s",
EchoObject(dest), dimen(dim), EchoConstraint(&c));
if( !FitsConstraint(back(y, dim), fwd(y, dim), c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling first component */
scaled = FALSE;
if( force_gall(hd) && size(y, dim) > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(y,dim), fwd(y,dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(y, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 4, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 5, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
y = InterposeScale(y, scale_factor, dim);
scaled = TRUE;
}
}
/* otherwise we must reject, and warn the user */
if( !scaled )
{ char num1[20], num2[20];
debug3(DGA, D, " reject: vsize %s,%s in %s; y=",
EchoLength(back(y, dim)), EchoLength(fwd(y, dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
if( size(y, dim) > 0 )
{ sprintf(num1, "%.1fc", (float) size(y, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 12, "%s object too high for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
else
Error(19, 13, "%s object too wide for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
}
goto REJECT;
}
}
/* check availability of perpendicular space for first component */
if( dim == ROWM )
{ perp_back = back(hd, 1-dim); perp_fwd = fwd(hd, 1-dim);
}
else
{ perp_back = back(y, 1-dim); perp_fwd = fwd(y, 1-dim);
}
Constrained(dest, &c, 1-dim, &junk);
debug3(DGF, DD, " dest perpendicular Constrained(%s, %s) = %s",
EchoObject(dest), dimen(1-dim), EchoConstraint(&c));
if( !FitsConstraint(perp_back, perp_fwd, c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling first component */
scaled = FALSE;
if( force_gall(hd) && perp_back + perp_fwd > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(perp_back, perp_fwd, &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) (perp_back + perp_fwd) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( 1-dim == ROWM )
Error(19, 6, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 7, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
y = InterposeScale(y, scale_factor, 1-dim);
scaled = TRUE;
}
}
/* otherwise we must reject, and warn the user */
if( !scaled )
{
debug3(DGA, D, " reject: vsize %s,%s in %s; y=",
EchoLength(perp_back), EchoLength(perp_fwd),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
goto REJECT;
}
}
/* dest seems OK, so perform its size adjustments */
debug0(DSA, D, "calling AdjustSize from AttachGalley (a)");
AdjustSize(dest, back(y, dim), fwd(y, dim), dim);
debug0(DSA, D, "calling AdjustSize from AttachGalley (b)");
AdjustSize(dest, perp_back, perp_fwd, 1-dim);
/* now check parallel space for target_galley in target */
Constrained(target, &c, dim, &why);
debug3(DGF, DD, " target parallel Constrained(%s, %s) = %s",
EchoObject(target), dimen(dim), EchoConstraint(&c));
Child(z, LastDown(target_galley)); /* works in all cases? */
assert( !is_index(type(z)), "AttachGalley: is_index(z)!" );
assert( back(z, dim)>=0 && fwd(z, dim)>=0, "AttachGalley: z size!" );
if( !FitsConstraint(back(z, dim), fwd(z, dim), c) )
{ BOOLEAN scaled;
debug2(DGA, D, " why = %d %s", (int) why, EchoObject(why));
debug2(DGA, D, " limiter = %d %s", (int) limiter(hd),
EchoObject(limiter(hd)));
/* if forcing galley doesn't fit, try scaling z */
scaled = FALSE;
if( force_gall(hd) && size(z, dim) > 0 && limiter(hd) != why )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(z,dim), fwd(z,dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(z, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 8, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 9, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
z = InterposeWideOrHigh(z, dim);
z = InterposeScale(z, scale_factor, dim);
scaled = TRUE;
}
}
if( !scaled )
{ char num1[20], num2[20];
limiter(hd) = why;
debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)),
(int) limiter(hd), EchoObject(limiter(hd)));
debug3(DGA, D, " reject: size was %s,%s in %s; y =",
EchoLength(back(z, dim)), EchoLength(fwd(z, dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
if( size(z, dim) > 0 )
{ sprintf(num1, "%.1fc", (float) size(z, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 14, "%s object too high for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
else
Error(19, 15, "%s object too wide for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
}
goto REJECT;
}
}
limiter(hd) = why;
debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)),
(int) limiter(hd), EchoObject(limiter(hd)));
/* now check perpendicular space for target_galley in target */
Constrained(target, &c, 1-dim, &junk);
debug3(DGF, DD, " target perpendicular Constrained(%s, %s) = %s",
EchoObject(target), dimen(1-dim), EchoConstraint(&c));
Child(z, LastDown(target_galley)); /* works in all cases? */
assert( !is_index(type(z)), "AttachGalley: is_index(z)!" );
assert( back(z, 1-dim)>=0 && fwd(z, 1-dim)>=0,
"AttachGalley: z size (perpendicular)!" );
if( !FitsConstraint(back(z, 1-dim), fwd(z, 1-dim), c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling z */
scaled = FALSE;
if( force_gall(hd) && size(z, 1-dim) > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(z,1-dim), fwd(z,1-dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(z, 1-dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( 1-dim == ROWM )
Error(19, 10, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 11, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
z = InterposeWideOrHigh(z, 1-dim);
z = InterposeScale(z, scale_factor, 1-dim);
scaled = TRUE;
}
}
if( !scaled )
{
debug3(DGA, D, " reject: size was %s,%s in %s; y =",
EchoLength(back(z, 1-dim)), EchoLength(fwd(z, 1-dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
goto REJECT;
}
}
/* target seems OK, so adjust sizes and accept */
if( external_hor(target) )
{
/* don't adjust any sizes, none to adjust */
debug0(DSA, D, "not calling AdjustSize from AttachGalley (c)");
}
else if( external_ver(target) )
{
/* adjust perp size only, to galley size */
debug0(DSA, D, "calling AdjustSize from AttachGalley (d)");
AdjustSize(target, back(target_galley, 1-dim),
fwd(target_galley, 1-dim), 1-dim);
}
else
{
/* adjust both directions, using z (last component) */
Child(z, LastDown(target_galley));
debug0(DSA, D, "AttachGalley AdjustSize using z =");
ifdebug(DSA, D, DebugObject(z));
debug0(DSA, D, "calling AdjustSize from AttachGalley (e)");
AdjustSize(target, back(z, dim), fwd(z, dim), dim);
debug0(DSA, D, "calling AdjustSize from AttachGalley (f)");
AdjustSize(target, back(z, 1-dim), fwd(z, 1-dim), 1-dim);
}
goto ACCEPT;
default:
assert1(FALSE, "AttachGalley:", Image(type(y)));
break;
} /* end switch */
} /* end for */
/* null galley: promote whole galley without expanding the target */
debug0(DGA, D, " null galley");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
LeaveErrorBlock(FALSE);
debug0(DYY, D, "] LeaveErrorBlock(FALSE) (null galley)");
/* kill off any null objects within the galley, then transfer it */
/* don't use Promote() since it does extra unwanted things here */
for( link = Down(hd); link != hd; link = NextDown(link) )
{ Child(y, link);
switch( type(y) )
{
case GAP_OBJ:
case CLOSURE:
case CROSS:
case FORCE_CROSS:
case NULL_CLOS:
case PAGE_LABEL:
link = PrevDown(link);
debug1(DGA, D, " null galley, disposing %s", Image(type(y)));
DisposeChild(NextDown(link));
break;
default:
break;
}
}
TransferLinks(NextDown(hd), hd, Up(target_index));
/* attach hd temporarily to target_index */
MoveLink(Up(hd), target_index, PARENT);
assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" );
DeleteNode(hd_index);
/* return; only hd_inners needs to be flushed now */
*inners = hd_inners;
debug0(DGA, D, "] AttachGalley returning ATTACH_NULL");
return ATTACH_NULL;
REJECT:
/* reject first component */
/* debug1(DGA, D, " reject %s", EchoObject(y)); */
debug0(DGA, D, " reject first component");
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (REJECT)");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
if( foll_or_prec(hd) == GALL_PREC && !sized(hd) )
{
/* move to just before the failed target */
MoveLink(Up(hd_index), Up(target_index), PARENT);
}
else
{
/* move to just after the failed target */
MoveLink(Up(hd_index), NextDown(Up(target_index)), PARENT);
}
continue;
SUSPEND:
/* suspend at first component */
debug1(DGA, D, " suspend %s", EchoIndex(y));
blocked(y) = TRUE;
LeaveErrorBlock(FALSE);
debug0(DYY, D, "] LeaveErrorBlock(FALSE) (SUSPEND)");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
MoveLink(Up(hd_index), Up(target_index), PARENT);
if( was_sized )
{ /* nothing new to flush if suspending and already sized */
if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj;
*inners = nilobj;
}
else
{ /* flush newly discovered inners if not sized before */
*inners = hd_inners;
}
debug0(DGA, D, "] AttachGalley returning ATTACH_SUSPEND");
*suspend_pt = y;
return ATTACH_SUSPEND;
ACCEPT:
/* accept first component; now committed to the attach */
debug3(DGA, D, " accept %s %s %s", Image(type(y)), EchoObject(y),
EchoFilePos(&fpos(y)));
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (ACCEPT)");
/* attach hd to dest */
MoveLink(Up(hd), dest_index, PARENT);
assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" );
DeleteNode(hd_index);
/* move first component of hd into dest */
/* nb Interpose must be done after all AdjustSize calls */
if( dim == ROWM && !external_ver(dest) )
Interpose(dest, VCAT, hd, y);
else if( dim == COLM && !external_hor(dest) )
{ Interpose(dest, ACAT, y, y);
Parent(junk, Up(dest));
assert( type(junk) == ACAT, "AttachGalley: type(junk) != ACAT!" );
StyleCopy(save_style(junk), save_style(dest));
adjust_cat(junk) = padjust(save_style(junk));
}
debug1(DGS, D, "calling Promote(hd, %s) from AttachGalley/ACCEPT",
link == hd ? "hd" : "NextDown(link)");
Promote(hd, link == hd ? hd : NextDown(link), dest_index, TRUE);
/* move target_galley into target */
/* nb Interpose must be done after all AdjustSize calls */
if( !(external_ver(target) || external_hor(target)) )
{ Child(z, LastDown(target_galley));
Interpose(target, VCAT, z, z);
}
debug0(DGS, D, "calling Promote(target_galley) from AttachGalley/ACCEPT");
Promote(target_galley, target_galley, target_index, TRUE);
DeleteNode(target_galley);
assert(Down(target_index)==target_index, "AttachGalley: target_ind");
if( blocked(target_index) ) blocked(dest_index) = TRUE;
DeleteNode(target_index);
/* return; both tg_inners and hd_inners need to be flushed now; */
/* if was_sized, hd_inners contains the inners of the first component; */
/* otherwise it contains the inners of all components, from SizeGalley */
if( tg_inners == nilobj ) *inners = hd_inners;
else if( hd_inners == nilobj ) *inners = tg_inners;
else
{ TransferLinks(Down(hd_inners), hd_inners, tg_inners);
DeleteNode(hd_inners);
*inners = tg_inners;
}
debug0(DGA, D, "] AttachGalley returning ATTACH_ACCEPT");
ifdebug(DGA, D,
if( dim == COLM && !external_hor(dest) )
{ OBJECT z;
Parent(z, Up(dest));
debug2(DGA, D, " COLM dest_encl on exit = %s %s",
Image(type(z)), EchoObject(z));
}
)
return ATTACH_ACCEPT;
} /* end for */
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
// open database connection
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName("/Users/jdoud/dev/brainstorm.sqlite");
if(!db.open())
{
qDebug() << db.lastError();
qFatal("Failed to connect.");
}
// setup UI
ui->setupUi(this);
ui->toolBar->addWidget(ui->comboFonts);
ui->toolBar->addWidget(ui->comboFontSizes);
ui->toolBar->addWidget(ui->comboColors);
// set text editor defaults
ui->textNote->document()->setIndentWidth(20);
ui->textNote->setTabStopWidth(20);
ui->textNote->setTabChangesFocus(false);
ui->actionIncrease_Indent->setShortcut(Qt::Key_Tab);
ui->actionDecrease_Indent->setShortcut(Qt::Key_Backtab);
// setup comboColors
QPixmap pix(16, 16);
pix.fill(Qt::white);
ui->comboColors->addItem(pix, "");
pix.fill(Qt::black);
ui->comboColors->addItem(pix, "");
pix.fill(Qt::red);
ui->comboColors->addItem(pix, "");
pix.fill(Qt::blue);
ui->comboColors->addItem(pix, "");
pix.fill(Qt::darkGreen);
ui->comboColors->addItem(pix, "");
pix.fill(Qt::gray);
ui->comboColors->addItem(pix, "");
// create system tray icon
createActions();
createTrayIcon();
// create models
categoriesModel = new QSqlTableModel();
categoriesModel->setTable("categories");
categoriesModel->setSort(1, Qt::AscendingOrder);
categoriesModel->select();
ui->listCategories->setModel(categoriesModel);
ui->listCategories->setModelColumn(1);
notesModel = new QSqlTableModel();
notesModel->setTable("notes");
ui->listNotes->setModel(notesModel);
ui->listNotes->setModelColumn(2);
// set splitter size
QList<int> sizes;
sizes << 230 << 150;
ui->splitterLists->setSizes(sizes);
sizes.clear();
sizes << 230 << 600;
ui->splitterNote->setSizes(sizes);
// connect File menu slots
connect(ui->actionNew_Category, SIGNAL(triggered()), this, SLOT(newCategory()));
connect(ui->actionRename_Category, SIGNAL(triggered()), this, SLOT(renameCategory()));
connect(ui->actionDelete_Category, SIGNAL(triggered()), this, SLOT(deleteCategory()));
connect(ui->actionNew_Note, SIGNAL(triggered()), this, SLOT(newNote()));
connect(ui->actionRename_Note, SIGNAL(triggered()), this, SLOT(renameNote()));
connect(ui->actionSave_Note, SIGNAL(triggered()), this, SLOT(saveNote()));
connect(ui->actionDelete_Note, SIGNAL(triggered()), this, SLOT(deleteNote()));
connect(ui->actionQuit, SIGNAL(triggered()), this, SLOT(quit()));
// connect Edit menu slots
connect(ui->actionFind_Replace, SIGNAL(triggered()), this, SLOT(findAndReplace()));
// connect Format menu slots
connect(ui->actionBold, SIGNAL(triggered()), this, SLOT(bold()));
connect(ui->actionItalic, SIGNAL(triggered()), this, SLOT(italic()));
connect(ui->actionUnderline, SIGNAL(triggered()), this, SLOT(underline()));
connect(ui->actionStrikethrough, SIGNAL(triggered()), this, SLOT(strikethrough()));
connect(ui->actionBullet_List, SIGNAL(triggered()), this, SLOT(bulletList()));
connect(ui->actionNumber_List, SIGNAL(triggered()), this, SLOT(numberList()));
connect(ui->actionIncrease_Indent, SIGNAL(triggered()), this, SLOT(increaseIndent()));
connect(ui->actionDecrease_Indent, SIGNAL(triggered()), this, SLOT(decreaseIndent()));
connect(ui->actionShow_Colors, SIGNAL(triggered()), this, SLOT(showColors()));
connect(ui->actionShow_Fonts, SIGNAL(triggered()), this, SLOT(showFonts()));
connect(ui->actionIncrease_Font, SIGNAL(triggered()), this, SLOT(increaseFont()));
connect(ui->actionDecrease_Font, SIGNAL(triggered()), this, SLOT(decreaseFont()));
connect(ui->actionReset_Font, SIGNAL(triggered()), this, SLOT(resetFont()));
connect(ui->actionAlign_Left, SIGNAL(triggered()), this, SLOT(alignLeft()));
connect(ui->actionAlign_Center, SIGNAL(triggered()), this, SLOT(alignCenter()));
connect(ui->actionAlign_Right, SIGNAL(triggered()), this, SLOT(alignRight()));
connect(ui->actionAlign_Justify, SIGNAL(triggered()), this, SLOT(alignJustify()));
// connect View menu slots
connect(ui->actionHide_Window, SIGNAL(triggered()), this, SLOT(hide()));
connect(ui->actionPrevious_Category, SIGNAL(triggered()), this, SLOT(previousCategory()));
connect(ui->actionNext_Category, SIGNAL(triggered()), this, SLOT(nextCategory()));
connect(ui->actionPrevious_Note, SIGNAL(triggered()), this, SLOT(previousNote()));
connect(ui->actionNext_Note, SIGNAL(triggered()), this, SLOT(nextNote()));
// connect Help menu slots
connect(ui->actionAbout_Brainstorm, SIGNAL(triggered()), this, SLOT(aboutBrainstorm()));
connect(ui->actionAbout_Qt, SIGNAL(triggered()), this, SLOT(aboutQt()));
// connect application slots
connect(ui->textNote, SIGNAL(cursorPositionChanged()), this, SLOT(updateMenus()));
connect(ui->textNote, SIGNAL(currentCharFormatChanged(QTextCharFormat)), this, SLOT(updateMenus()));
connect(ui->comboFonts, SIGNAL(activated(QString)), this, SLOT(setFont(QString)));
connect(ui->comboFontSizes, SIGNAL(activated(QString)), this, SLOT(setFontSize(QString)));
connect(ui->comboColors, SIGNAL(activated(int)), this, SLOT(setFontColor(int)));
// connect category list slots
connect(ui->listCategories->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(updateNoteList(QModelIndex)));
// connect note list slots
connect(ui->listNotes->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(updateNoteText(QModelIndex)));
// connect text slots
ui->textNote->installEventFilter((this));
// connect system tray icon
connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(iconActivated(QSystemTrayIcon::ActivationReason)));
// initialize default data
ui->listCategories->selectionModel()->setCurrentIndex(categoriesModel->index(0, 1), QItemSelectionModel::SelectCurrent);
}
