i_notebk.cpp

windriver_VxWorks.zinc60t22 zin6.0 for tornado 2.2 patch

	SetAutomaticUpdate(true);

	// Return the current tab number.
	return (setCurrentTab);
}

bool ZafNotebookTabControl::SetSupportObject(bool setSupportObject)
{
	// Make sure the attribute has changed.
	if (supportObject != setSupportObject)
		supportObject = setSupportObject;

	// Return the current attribute.
	return (supportObject);
}

ZafWindowObject *ZafNotebookTabControl::Subtract(ZafWindowObject *object)
{
	bool saveUpdate = automaticUpdate;
	SetAutomaticUpdate(false);
	ZafWindowObject *retVal = ZafWindow::Subtract(object);
	if (object == currentTab)
		currentTab = ZAF_NULLP(ZafWindowObject);
	if (screenID)
		Event(N_SIZE);
	SetAutomaticUpdate(saveUpdate);

	return (retVal);
}

void ZafNotebookTabControl::OSUpdateRegions(const ZafEventStruct *updateEvent)
{
	if (AutomaticUpdate() && Visible() && screenID)
	{
		ZafEventStruct event(S_REDISPLAY_REGION);

		ZafWindowObject *object;
		UGL_RECT rect;

		// draw the frame (non-client area).
		if (!updateEvent || updateEvent->osEvent.header.objectId == screenID)
		{
			event.region = zafRegion;
			event.region.HzShift(-zafRegion.left);
			event.region.VtShift(-zafRegion.top);
			display->BeginDraw(ID_ZAF_DIRTY_REGION, screenID, zafRegion, zafRegion);
			DrawFrame(event, S_REDISPLAY_REGION);
			display->EndDraw();
	
			// Draw the scrollArrows, if present.
			object = SupportFirst();
			if (object)
				object->OSUpdateRegions();
	
			if (SystemObject())
			{
				rect.left = zafRegion.left;
				rect.top = zafRegion.top;
				rect.right = zafRegion.right;
				rect.bottom = zafRegion.bottom;
				// Normalize to 0-based coordinates for the object.
				UGL_RECT_MOVE(rect, -rect.left, -rect.top);
	
				winRectValidate(screenID, &rect);
			}
		}

		// draw the client.
		if (!updateEvent || updateEvent->osEvent.header.objectId == clientID)
		{
			event.region.HzShift(-clientRegion.left);
			if (event.region.left < 0)
				event.region.left = 0;
			event.region.VtShift(-clientRegion.top);
			if (event.region.top < 0)
				event.region.top = 0;
			display->BeginDraw(ID_ZAF_DIRTY_REGION, clientID, zafRegion, zafRegion);
			Draw(event, S_REDISPLAY_REGION);
			display->EndDraw();
	
			// Draw current tab last, since it overlaps adjacent tabs.
			object = currentTab;
			if (object)
				object = object->Next() ? object->Next() : First();
	
			ZafRegionStruct childRegion;
	
			while (object)
			{
				object->OSUpdateRegions();
	
				// If just drew current tab, we're done, so break out of loop.
				if (object == currentTab)
					break;
				else
					object = object->Next() ? object->Next() : First();
			}
			if (SystemObject())
			{
				rect.left = clientRegion.left;
				rect.top = clientRegion.top;
				rect.right = clientRegion.right;
				rect.bottom = clientRegion.bottom;
	
				// Normalize to 0-based coordinates for the object.
				UGL_RECT_MOVE(rect, -rect.left, -rect.top);
	
				winRectValidate(clientID, &rect);
			}
		}
	}
}



// ----- ZafNotebookScrollArrows ---------------------------------------------------

#define ZAF_SCROLL_BUTTON_INFO
#include <zinc/data/img_def.hpp>
#if defined(ZAF_REENTRANT)
#	include <zinc/z_system.hpp>
#endif
#if defined(ZAF_REENTRANT)
ZafSemaphore *ZafNotebookScrollArrows::classSem = 0;
#endif

ZafNotebookScrollArrows::ZafNotebookScrollArrows(void) :
	ZafButton(0, 0, 0, 0, ZafLanguageManager::blankString),
	middle(0), scrollState(ZAF_SCROLL_NONE)
{
	SetBordered(false);
	SetHzJustify(ZAF_HZ_CENTER);
	SetSupportObject(true);
	SetAllowToggling(false);
	SetAutoSize(false);
	SetNoncurrent(true);
	SetRegionType(ZAF_AVAILABLE_REGION);
	Initialize();
}

ZafNotebookScrollArrows::ZafNotebookScrollArrows(const ZafNotebookScrollArrows &copy) :
	ZafButton(copy),
	middle(0), scrollState(ZAF_SCROLL_NONE)
{
	Initialize();
}

ZafNotebookScrollArrows::~ZafNotebookScrollArrows(void)
{
	ImageFree();
}

#if defined(ZAF_DEFAULT_DRAW)
ZafEventType ZafNotebookScrollArrows::ClassDraw(const ZafEventStruct &event,
	ZafEventType ccode)
{
	// Compute the actual draw region.
	ZafPaletteState state = PaletteState();
	ZafRegionStruct drawRegion = BeginDraw();

	// Draw shadow for top of page (runs along bottom of scroll arrows).
	ZafPaletteStruct whiteShadow = LogicalPalette(ZAF_PM_LIGHT_SHADOW, 0);
	ZafPaletteStruct blackShadow = LogicalPalette(ZAF_PM_DARK_SHADOW, 0);

	// Copy the background colors to the foreground since display->Line() uses
	// the foreground color. The "shadow" palettes have different colors in
	// the foreground and background entries so they can generate two shades
	// of shadow.
	whiteShadow.colorForeground = whiteShadow.colorBackground;
	blackShadow.colorForeground = blackShadow.colorBackground;

	drawRegion.bottom--;

	display->SetPalette(whiteShadow);
	display->Line(drawRegion.left, drawRegion.bottom, drawRegion.right - 1, drawRegion.bottom);
	display->SetPalette(blackShadow);
	display->Pixel(drawRegion.right, drawRegion.bottom, blackShadow.colorForeground);

	drawRegion.bottom--;

	// Draw "two" buttons.
	ZafPaletteStruct textPalette = LogicalPalette(ZAF_PM_BACKGROUND, state);
	ZafRegionStruct draw = drawRegion;

	// Draw right arrow.
	draw.left = middle + 1;
	DrawShadow(draw, scrollState == ZAF_SCROLL_RIGHT ? -1 : depth, ccode);
	display->SetPalette(textPalette);
	display->Rectangle(draw, 0, true);
	draw = drawRegion;
	draw.left = middle + 1;
	int width = draw.Width();
	int height = draw.Height();
	int bitmapWidth = scrollRightArrowBitmap->Width();
	int bitmapHeight = scrollRightArrowBitmap->Height();
	draw.left += width / 2 - bitmapWidth / 2;
	draw.top += height / 2 - bitmapHeight / 2;
	display->Bitmap(draw.left, draw.top, *scrollRightArrowBitmap);

	// Draw left arrow.
	draw = drawRegion;
	draw.right = middle;
	DrawShadow(draw, scrollState == ZAF_SCROLL_LEFT ? -1 : depth, ccode);
	display->SetPalette(textPalette);
	display->Rectangle(draw, 0, true);
	draw = drawRegion;
	draw.right = middle;
	width = draw.Width();
	height = draw.Height();
	bitmapWidth = scrollLeftArrowBitmap->Width();
	bitmapHeight = scrollLeftArrowBitmap->Height();
	draw.left += width / 2 - bitmapWidth / 2;
	draw.top += height / 2 - bitmapHeight / 2;
	display->Bitmap(draw.left, draw.top, *scrollLeftArrowBitmap);

	EndDraw();

	return (ccode);
}

ZafEventType ZafNotebookScrollArrows::DrawShadow(ZafRegionStruct &region,
	int depth, ZafEventType ccode)
{
	if (depth < 0)
		return (ZafButton::DrawShadow(region, depth, ccode));

	ZafPaletteStruct lightShadow;
	ZafPaletteStruct darkShadow;
	ZafPaletteStruct whiteShadow;
	ZafPaletteStruct blackShadow;
	ShadowPalettes(0, &lightShadow, &darkShadow, &whiteShadow, &blackShadow);

	// Draw the shadow pattern.
	display->SetPalette(lightShadow);
	display->Line(region.left, region.top, region.right - 1, region.top);
	display->Line(region.left, region.top, region.left, region.bottom - 1);

	display->SetPalette(whiteShadow);
	display->Line(region.left + 1, region.top + 1, region.right - 1, region.top + 1);
	display->Line(region.left + 1, region.top + 1, region.left + 1, region.bottom - 1);

	display->SetPalette(blackShadow);
	display->Line(region.left, region.bottom, region.right, region.bottom);
	display->Line(region.right, region.top, region.right, region.bottom);

	display->SetPalette(darkShadow);
	display->Line(region.left + 1, region.bottom - 1, region.right - 1, region.bottom - 1);
	display->Line(region.right - 1, region.top + 1, region.right - 1, region.bottom - 1);

	region -= ZAF_BORDER_SIZE;

	return (ccode);
}
#endif

ZafEventType ZafNotebookScrollArrows::Event(const ZafEventStruct &event)
{
 	// Switch on the event type.
	ZafEventType ccode = LogicalEvent(event);
	switch (ccode)
	{
	case S_INITIALIZE:
		ccode = ZafButton::Event(event);
#if defined(ZAF_REENTRANT)
		ZafNotebookScrollArrows::classSem->Take(ZAF_WAIT_FOREVER_SEMAPHORE);
#endif

		// scrollLeftArrowBitmap
		if (!scrollLeftArrowBitmap->handle)
		{
			display->ConvertToOSBitmap(*scrollLeftArrowBitmap);
			display->ConvertToOSBitmap(*scrollRightArrowBitmap);
		}

#if defined(ZAF_REENTRANT)
		ZafNotebookScrollArrows::classSem->Give();
#endif
		break;

	case S_COMPUTE_SIZE:
		// Suppress, since the tab control already set the size.
		ZafWindowObject::Event(event);
		zafRegion.left = zafRegion.right - 20;
		middle = zafRegion.Width() / 2;
		break;

	case L_BEGIN_SELECT:
	case L_CONTINUE_SELECT:
		{
			ZafPositionStruct mousePosition = event.position;

			ZafScrollState saveState = scrollState;

			int right = zafRegion.right - zafRegion.left;
			int bottom = zafRegion.bottom - zafRegion.top;

			if (mousePosition.line < 0 || mousePosition.line > bottom ||
				mousePosition.column < 0 || mousePosition.column > right)
				scrollState = ZAF_SCROLL_NONE;
			else if (mousePosition.column <= middle)
				scrollState = ZAF_SCROLL_LEFT;
			else
				scrollState = ZAF_SCROLL_RIGHT;

			if (saveState != scrollState)
				Event(S_REDISPLAY);

			ZafScrollStruct scroll;
			if (scrollState == ZAF_SCROLL_LEFT)
			{
				scroll.delta = -1;
				parent->Event(ZafEventStruct(S_HSCROLL, 0, scroll));
			}
			else if (scrollState == ZAF_SCROLL_RIGHT)
			{
				scroll.delta = 1;
				parent->Event(ZafEventStruct(S_HSCROLL, 0, scroll));
			}

			if (ccode == L_BEGIN_SELECT)
			{
				ZafTimer *repeatTimer = new ZafTimer(D_ON, InitialDelay());
				repeatTimer->Add(this, N_INITIAL_DELAY);
				repeatTimer->SetStringID(ZAF_ITEXT("ZafButtonRepeat"));
				EventManager()->Add(repeatTimer);
				WindowManager()->CaptureMouse(this);
			}
		}
		break;

	case L_END_SELECT:
		{
			ZafScrollState saveState = scrollState;
			if (WindowManager()->MouseEventRoute() == this)
				WindowManager()->CaptureMouse(ZAF_NULLP(ZafWindowObject));

			ZafDevice *repeatTimer = EventManager()->GetObject(ZAF_ITEXT("ZafButtonRepeat"));
			if (repeatTimer)
			{
				EventManager()->Subtract(repeatTimer);
				delete repeatTimer;
			}
			scrollState = ZAF_SCROLL_NONE;
			if (saveState != scrollState)
				Event(S_REDISPLAY);
		}
		break;

	case N_INITIAL_DELAY:
	case N_REPEAT_DELAY:
		{
			ZafScrollStruct scroll;
			if (scrollState == ZAF_SCROLL_LEFT)
			{
				scroll.delta = -1;
				parent->Event(ZafEventStruct(S_HSCROLL, 0, scroll));
			}
			else if (scrollState == ZAF_SCROLL_RIGHT)
			{
				scroll.delta = 1;
				parent->Event(ZafEventStruct(S_HSCROLL, 0, scroll));
			}
			if (ccode == N_INITIAL_DELAY)
			{
				ZafTimer *repeatTimer = DynamicPtrCast(EventManager()->GetObject(ZAF_ITEXT("ZafButtonRepeat")),
					ZafTimer);
				if (repeatTimer)
				{
					repeatTimer->SetNotifyMessage(N_REPEAT_DELAY);
					repeatTimer->SetInterval(RepeatDelay());
				}
			}
		}
		break;

	default:
		ccode = ZafButton::Event(event);
		break;
	}

	// Return the control code.
	return (ccode);
}

void ZafNotebookScrollArrows::ImageAllocate(void)
{
#if defined(ZAF_REENTRANT)
	ZafNotebookScrollArrows::classSem->Take(ZAF_WAIT_FOREVER_SEMAPHORE);
#endif

	// scrollLeftArrowBitmap
	if (!scrollLeftArrowBitmap)
	{
		ZafI18nData::AddStaticModule(ImageFree);
		scrollLeftArrowBitmap = new ZafBitmapData(_scrollLeftArrow_ZafBitmap);
		scrollLeftArrowBitmap->staticHandle = true;
		scrollLeftArrowBitmap->SetDestroyable(false);

		scrollRightArrowBitmap = new ZafBitmapData(_scrollRightArrow_ZafBitmap);
		scrollRightArrowBitmap->staticHandle = true;
		scrollRightArrowBitmap->SetDestroyable(false);
	}

#if defined(ZAF_REENTRANT)
	ZafNotebookScrollArrows::classSem->Give();
#endif

}

void ZafNotebookScrollArrows::ImageFree(bool globalRequest)
{
#if defined(ZAF_REENTRANT)
	ZafNotebookScrollArrows::classSem->Take(ZAF_WAIT_FOREVER_SEMAPHORE);
#endif

	// Destroy the static images.
	if (globalRequest && scrollLeftArrowBitmap)
	{
		scrollLeftArrowBitmap->staticHandle = false;
		delete scrollLeftArrowBitmap;
		scrollLeftArrowBitmap = ZAF_NULLP(ZafBitmapData);
		scrollRightArrowBitmap->staticHandle = false;
		delete scrollRightArrowBitmap;
		scrollRightArrowBitmap = ZAF_NULLP(ZafBitmapData);
	}

#if defined(ZAF_REENTRANT)
	ZafNotebookScrollArrows::classSem->Give();
#endif

}

void ZafNotebookScrollArrows::Initialize()
{
   	// Initialize class-wide info.
	if (!scrollLeftArrowBitmap)
	{
#if defined(ZAF_REENTRANT)
		ZafSystem::InitializeSemaphore(ZafNotebookScrollArrows::classSem);
#endif

		ImageAllocate();

#if defined(ZAF_REENTRANT)
		ZafNotebookScrollArrows::classSem->Give();
#endif
	}
}

bool ZafNotebookScrollArrows::SetSupportObject(bool setSupportObject)
{
	// Make sure the attribute has changed.
	if (supportObject != setSupportObject)
		supportObject = setSupportObject;

	// Return the current attribute.
	return (supportObject);
}

// ----- OS Specific Functions ----------------------------------------------

void ZafNotebookTab::OSInvalidateRegion(ZafRegionStruct *region, bool immediateRedraw, bool, bool redisplay)
{
	if (AutomaticUpdate() && Visible() && screenID)
	{
		ZafRegionStruct tRegion = region ? *region : zafRegion;
		tRegion.HzShift(zafRegion.left);
		tRegion.VtShift(zafRegion.top);
		parent->OSInvalidateRegion(&tRegion, immediateRedraw, !SupportObject(), redisplay);
	}
}