utils/screenshotgen/src/autocapture.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        autocapture.cpp
// Purpose:     Implement wxCtrlMaskOut class
// Author:      Utensil Candel (UtensilCandel@@gmail.com)
// RCS-ID:      $Id$
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#include "autocapture.h"

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "wx/bitmap.h"
#include "wx/filename.h"
#include "wx/notebook.h"

#include <ctime>

#ifdef __WXMAC__
#include <cstring>
#endif


// ----------------------------------------------------------------------------
// AutoCaptureMechanism
// ----------------------------------------------------------------------------

AutoCaptureMechanism::AutoCaptureMechanism(wxNotebook *notebook,
                                           int flag, int margin)
: m_notebook(notebook),
  m_flag(flag),
  m_margin(margin),
  m_grid(NULL)
{
}

/* static */
wxString AutoCaptureMechanism::default_dir = wxT("screenshots");

/* static */
wxString AutoCaptureMechanism::GetDefaultDirectoryAbsPath()
{
    wxFileName output = wxFileName::DirName(GetDefaultDirectory());
    output.MakeAbsolute();
    return output.GetFullPath();
}

/* static */
void AutoCaptureMechanism::Delay(int seconds)
{
    // TODO: Switch this to use wxTimer.

    // Wait for 3 seconds
    clock_t start = clock();
    while ( clock() - start < (clock_t)CLOCKS_PER_SEC * seconds)
        wxYieldIfNeeded();
}

/* static */
bool AutoCaptureMechanism::Capture(wxBitmap* bitmap, int x, int y,
                                   int width, int height, int delay)
{
    // Somehow wxScreenDC.Blit() doesn't work under Mac for now. Here is a trick.
#ifdef __WXMAC__

    // wxExecute(wxT("screencapture -x ") + tempfile, wxEXEC_SYNC);

    char captureCommand[80] =""; // a reasonable max size is 80
    sprintf(captureCommand, "sleep %d;%s", delay, "screencapture -x /tmp/wx_screen_capture.png");
    system(captureCommand);

    if(delay) Delay(delay);

    wxBitmap fullscreen;
    do
    {
        fullscreen = wxBitmap(wxT("/tmp/wx_screen_capture.png"), wxBITMAP_TYPE_PNG);
    }
    while(!fullscreen.IsOk());

    *bitmap = fullscreen.GetSubBitmap(wxRect(x, y, width, height));

    // to prevent loading the old screenshot next time
    system("rm /tmp/wx_screen_capture.png");

    return true;

#else // Under other paltforms, take a real screenshot

    if(delay) Delay(delay);

    // Create a DC for the whole screen area
    wxScreenDC dcScreen;

    bitmap->Create(width, height);

    // Create a memory DC that will be used for actually taking the screenshot
    wxMemoryDC memDC;
    memDC.SelectObject((*bitmap));
    memDC.Clear();

    // Blit (in this case copy) the actual screen on the memory DC
    // and thus the Bitmap
    memDC.Blit( 0, // Copy to this X coordinate
                0, // Copy to this Y coordinate
                width, // Copy this width
                height, // Copy this height
                &dcScreen, // From where do we copy?
                x, // What's the X offset in the original DC?
                y  // What's the Y offset in the original DC?
              );

    // Select the Bitmap out of the memory DC by selecting a new
    // uninitialized Bitmap
    memDC.SelectObject(wxNullBitmap);
#endif // #ifdef __WXMAC__

    return true;
}

/* static */
bool AutoCaptureMechanism::Capture(wxBitmap* bitmap, wxRect rect, int delay)
{
    wxPoint origin = rect.GetPosition();
    return Capture(bitmap, origin.x, origin.y, rect.GetWidth(), rect.GetHeight(), delay);
}

/* static */
void AutoCaptureMechanism::Save(wxBitmap* screenshot, const wxString& fileName)
{
    // make sure default_dir exists
    if (!wxDirExists(default_dir))
        wxMkdir(default_dir);

    wxFileName fullFileName(default_dir, "appear-" + fileName +
        "-" + wxPlatformInfo::Get().GetPortIdShortName() + ".png");

    // do not overwrite already existing files with this name
    while (fullFileName.FileExists())
        fullFileName.SetName(fullFileName.GetName() + "_");

    // save the screenshot as a PNG
    screenshot->SaveFile(fullFileName.GetFullPath(), wxBITMAP_TYPE_PNG);
}

void AutoCaptureMechanism::CaptureAll()
{
    // start from the first page
    m_notebook->SetSelection(0);
    wxYield();

    for (ControlList::iterator it = m_controlList.begin();
         it != m_controlList.end();
         ++it)
    {
        Control &ctrl = *it;

        if (ctrl.flag == AJ_TurnPage)    // Turn to next page
        {
            m_notebook->SetSelection(m_notebook->GetSelection() + 1);
            wxYield();
            continue;
        }

        // create the screenshot
        wxBitmap screenshot(1, 1);
        Capture(&screenshot, ctrl);

        if(ctrl.flag & AJ_Union)
        {
            // union screenshots until AJ_UnionEnd
            do
            {
                ++it;
                it->name = ctrl.name; //preserving the name
                wxBitmap screenshot2(1, 1);
                Capture(&screenshot2, *it);
                wxBitmap combined(1, 1);
                Union(&screenshot, &screenshot2, &combined);
                screenshot = combined;
            }
            while(!(it->flag & AJ_UnionEnd));
        }

        // and save it
        Save(&screenshot, ctrl.name);
    }
}

bool AutoCaptureMechanism::Capture(wxBitmap* bitmap, Control& ctrl)
{
    // no manual specification for the control name
    // or name adjustment is disabled globally
    if (ctrl.name == wxT("") || m_flag & AJ_DisableNameAdjust)
    {
        // Get its name from wxRTTI
        ctrl.name = ctrl.ctrl->GetClassInfo()->GetClassName();
    }

    int choice = wxNO;

    wxRect rect = GetRect(ctrl.ctrl, ctrl.flag);

    if (ctrl.flag & AJ_Dropdown && !(m_flag & AJ_DisableDropdown))
    {
        // for drop-down controls we need the help of the user
        wxString caption = _("Drop-down screenshot...");
        wxString msg =
            wxString::Format(_("Do you wish to capture the drop-down list of '%s' ?\n\n If YES, please drop down the list of '%s' in 5 seconds after closing this message box.\n If NO, the screenshot for this control won't contain its drop-down list."),
                             ctrl.name, ctrl.name);

        choice = wxMessageBox(msg, caption, wxYES_NO, m_notebook);

        if (choice == wxYES)
        {
            //A little hint
            ctrl.ctrl->SetCursor(wxCursor(wxCURSOR_HAND));

            // Do some rect adjust so it can include the dropdown list
            // This adjust isn't pretty, but it works fine on all three paltforms.
            // Looking forward to a better solution
            int h = rect.GetHeight();
            rect.SetHeight(h * 4);
        }
    }

    // cut off "wx" and change the name into lowercase.
    // e.g. wxButton will have a name of "button" at the end
    ctrl.name.StartsWith(wxT("wx"), &(ctrl.name));
    ctrl.name.MakeLower();

    // take the screenshot
    Capture(bitmap, rect, (choice == wxYES)?5:0);

    if (choice == wxYES) ctrl.ctrl->SetCursor(wxNullCursor);

    if (ctrl.flag & AJ_RegionAdjust)
        PutBack(ctrl.ctrl);

    return true;
}

/* static */
bool AutoCaptureMechanism::Union(wxBitmap* top, wxBitmap* bottom, wxBitmap* result)
{
    int w1, w2, h1, h2, w, h;
    w1 = top->GetWidth();
    w2 = bottom->GetWidth();
    h1 = top->GetHeight();
    h2 = bottom->GetHeight();

    const int gap_between = 20;

    w = (w1 >= w2) ? w1 : w2;
    h = h1 + h2 + gap_between;

    result->Create(w, h);

    wxMemoryDC dstDC;
    dstDC.SelectObject((*result));

    dstDC.SetBrush(*wxWHITE_BRUSH);
    dstDC.Clear();
    dstDC.DrawBitmap((*top), 0, 0);
    dstDC.DrawBitmap((*bottom), 0, h1 + gap_between);

    dstDC.SelectObject(wxNullBitmap);

    return true;
}

wxRect AutoCaptureMechanism::GetRect(wxWindow* ctrl, int flag)
{
    if( (!(m_flag & AJ_DisableRegionAdjust) && (flag & AJ_RegionAdjust))
        || (m_flag & AJ_AlwaysRegionAdjust) )
    {
        wxWindow * parent = ctrl->GetParent();
        wxSizer * sizer = parent->GetSizer();

        //The assertion won't fail if controls are still managed by wxSizer, and it's unlikely to
        //change in the future.
        wxASSERT_MSG(sizer,
        "The GUI that AutoCaptureMechanism working with doesn't manage controls with wxSizer");

        sizer->Detach(ctrl);

        /*
        +---------+-----------+---------+
        |    0    |   label   |    1    |
        +---------+-----------+---------+
        |  label  |    ctrl   |  label  |
        +---------+-----------+---------+
        |    2    |   label   |    3    |
        +---------+-----------+---------+
       */

        m_grid = new wxFlexGridSizer(3, 3, m_margin, m_margin);

        wxStaticText* l[4];

        for (int i = 0; i < 4; ++i)
            l[i] = new wxStaticText(parent, wxID_ANY, wxT(" "));

        m_grid->Add(l[0]);
        m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
        m_grid->Add(l[1]);
        m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
        m_grid->Add(ctrl, 1, wxEXPAND);
        m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
        m_grid->Add(l[2]);
        m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
        m_grid->Add(l[3]);

        sizer->Add(m_grid);
        parent->SetSizer(sizer);
        parent->Layout();

        parent->Refresh();
        wxYield();

        return wxRect(l[0]->GetScreenRect().GetBottomRight(),
                l[3]->GetScreenRect().GetTopLeft());
    }
    else
    {
       return ctrl->GetScreenRect().Inflate(m_margin);
    }
}

void AutoCaptureMechanism::PutBack(wxWindow * ctrl)
{
    if(!m_grid) return;

    m_grid->Detach(ctrl);

    wxSizerItemList children = m_grid->GetChildren();

    for (wxSizerItemList::iterator it = children.begin(); it != children.end(); ++it)
    {
        wxSizerItem* item = *it;
        if (item->IsWindow()) delete (*it)->GetWindow();
    }

    wxSizer * sizer = ctrl->GetParent()->GetSizer();

    //The assertion won't fail if controls are still managed by wxSizer, and it's unlikely to
    //change in the future.
    wxASSERT_MSG(sizer,
    "The GUI that AutoCaptureMechanism working with doesn't manage controls with wxSizer");

    sizer->Detach(m_grid);
    delete m_grid;
    m_grid = NULL;

    sizer->Add(ctrl);
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: autocapture.cpp
	3	// Purpose: Implement wxCtrlMaskOut class
	4	// Author: Utensil Candel (UtensilCandel@@gmail.com)
	5	// RCS-ID: $Id$
	6	// Licence: wxWindows licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9	// For compilers that support precompilation, includes "wx/wx.h".
	10	#include "wx/wxprec.h"
	11
	12	#ifdef __BORLANDC__
	13	#pragma hdrstop
	14	#endif
	15
	16	#include "autocapture.h"
	17
	18	#ifndef WX_PRECOMP
	19	#include "wx/wx.h"
	20	#endif
	21
	22	#include "wx/bitmap.h"
	23	#include "wx/filename.h"
	24	#include "wx/notebook.h"
	25
	26	#include <ctime>
	27
	28	#ifdef __WXMAC__
	29	#include <cstring>
	30	#endif
	31
	32
	33	// ----------------------------------------------------------------------------
	34	// AutoCaptureMechanism
	35	// ----------------------------------------------------------------------------
	36
	37	AutoCaptureMechanism::AutoCaptureMechanism(wxNotebook *notebook,
	38	int flag, int margin)
	39	: m_notebook(notebook),
	40	m_flag(flag),
	41	m_margin(margin),
	42	m_grid(NULL)
	43	{
	44	}
	45
	46	/* static */
	47	wxString AutoCaptureMechanism::default_dir = wxT("screenshots");
	48
	49	/* static */
	50	wxString AutoCaptureMechanism::GetDefaultDirectoryAbsPath()
	51	{
	52	wxFileName output = wxFileName::DirName(GetDefaultDirectory());
	53	output.MakeAbsolute();
	54	return output.GetFullPath();
	55	}
	56
	57	/* static */
	58	void AutoCaptureMechanism::Delay(int seconds)
	59	{
	60	// TODO: Switch this to use wxTimer.
	61
	62	// Wait for 3 seconds
	63	clock_t start = clock();
	64	while ( clock() - start < (clock_t)CLOCKS_PER_SEC * seconds)
	65	wxYieldIfNeeded();
	66	}
	67
	68	/* static */
	69	bool AutoCaptureMechanism::Capture(wxBitmap* bitmap, int x, int y,
	70	int width, int height, int delay)
	71	{
	72	// Somehow wxScreenDC.Blit() doesn't work under Mac for now. Here is a trick.
	73	#ifdef __WXMAC__
	74
	75	// wxExecute(wxT("screencapture -x ") + tempfile, wxEXEC_SYNC);
	76
	77	char captureCommand[80] =""; // a reasonable max size is 80
	78	sprintf(captureCommand, "sleep %d;%s", delay, "screencapture -x /tmp/wx_screen_capture.png");
	79	system(captureCommand);
	80
	81	if(delay) Delay(delay);
	82
	83	wxBitmap fullscreen;
	84	do
	85	{
	86	fullscreen = wxBitmap(wxT("/tmp/wx_screen_capture.png"), wxBITMAP_TYPE_PNG);
	87	}
	88	while(!fullscreen.IsOk());
	89
	90	*bitmap = fullscreen.GetSubBitmap(wxRect(x, y, width, height));
	91
	92	// to prevent loading the old screenshot next time
	93	system("rm /tmp/wx_screen_capture.png");
	94
	95	return true;
	96
	97	#else // Under other paltforms, take a real screenshot
	98
	99	if(delay) Delay(delay);
	100
	101	// Create a DC for the whole screen area
	102	wxScreenDC dcScreen;
	103
	104	bitmap->Create(width, height);
	105
	106	// Create a memory DC that will be used for actually taking the screenshot
	107	wxMemoryDC memDC;
	108	memDC.SelectObject((*bitmap));
	109	memDC.Clear();
	110
	111	// Blit (in this case copy) the actual screen on the memory DC
	112	// and thus the Bitmap
	113	memDC.Blit( 0, // Copy to this X coordinate
	114	0, // Copy to this Y coordinate
	115	width, // Copy this width
	116	height, // Copy this height
	117	&dcScreen, // From where do we copy?
	118	x, // What's the X offset in the original DC?
	119	y // What's the Y offset in the original DC?
	120	);
	121
	122	// Select the Bitmap out of the memory DC by selecting a new
	123	// uninitialized Bitmap
	124	memDC.SelectObject(wxNullBitmap);
	125	#endif // #ifdef __WXMAC__
	126
	127	return true;
	128	}
	129
	130	/* static */
	131	bool AutoCaptureMechanism::Capture(wxBitmap* bitmap, wxRect rect, int delay)
	132	{
	133	wxPoint origin = rect.GetPosition();
	134	return Capture(bitmap, origin.x, origin.y, rect.GetWidth(), rect.GetHeight(), delay);
	135	}
	136
	137	/* static */
	138	void AutoCaptureMechanism::Save(wxBitmap* screenshot, const wxString& fileName)
	139	{
	140	// make sure default_dir exists
	141	if (!wxDirExists(default_dir))
	142	wxMkdir(default_dir);
	143
	144	wxFileName fullFileName(default_dir, "appear-" + fileName +
	145	"-" + wxPlatformInfo::Get().GetPortIdShortName() + ".png");
	146
	147	// do not overwrite already existing files with this name
	148	while (fullFileName.FileExists())
	149	fullFileName.SetName(fullFileName.GetName() + "_");
	150
	151	// save the screenshot as a PNG
	152	screenshot->SaveFile(fullFileName.GetFullPath(), wxBITMAP_TYPE_PNG);
	153	}
	154
	155	void AutoCaptureMechanism::CaptureAll()
	156	{
	157	// start from the first page
	158	m_notebook->SetSelection(0);
	159	wxYield();
	160
	161	for (ControlList::iterator it = m_controlList.begin();
	162	it != m_controlList.end();
	163	++it)
	164	{
	165	Control &ctrl = *it;
	166
	167	if (ctrl.flag == AJ_TurnPage) // Turn to next page
	168	{
	169	m_notebook->SetSelection(m_notebook->GetSelection() + 1);
	170	wxYield();
	171	continue;
	172	}
	173
	174	// create the screenshot
	175	wxBitmap screenshot(1, 1);
	176	Capture(&screenshot, ctrl);
	177
	178	if(ctrl.flag & AJ_Union)
	179	{
	180	// union screenshots until AJ_UnionEnd
	181	do
	182	{
	183	++it;
	184	it->name = ctrl.name; //preserving the name
	185	wxBitmap screenshot2(1, 1);
	186	Capture(&screenshot2, *it);
	187	wxBitmap combined(1, 1);
	188	Union(&screenshot, &screenshot2, &combined);
	189	screenshot = combined;
	190	}
	191	while(!(it->flag & AJ_UnionEnd));
	192	}
	193
	194	// and save it
	195	Save(&screenshot, ctrl.name);
	196	}
	197	}
	198
	199	bool AutoCaptureMechanism::Capture(wxBitmap* bitmap, Control& ctrl)
	200	{
	201	// no manual specification for the control name
	202	// or name adjustment is disabled globally
	203	if (ctrl.name == wxT("") \|\| m_flag & AJ_DisableNameAdjust)
	204	{
	205	// Get its name from wxRTTI
	206	ctrl.name = ctrl.ctrl->GetClassInfo()->GetClassName();
	207	}
	208
	209	int choice = wxNO;
	210
	211	wxRect rect = GetRect(ctrl.ctrl, ctrl.flag);
	212
	213	if (ctrl.flag & AJ_Dropdown && !(m_flag & AJ_DisableDropdown))
	214	{
	215	// for drop-down controls we need the help of the user
	216	wxString caption = _("Drop-down screenshot...");
	217	wxString msg =
	218	wxString::Format(_("Do you wish to capture the drop-down list of '%s' ?\n\n If YES, please drop down the list of '%s' in 5 seconds after closing this message box.\n If NO, the screenshot for this control won't contain its drop-down list."),
	219	ctrl.name, ctrl.name);
	220
	221	choice = wxMessageBox(msg, caption, wxYES_NO, m_notebook);
	222
	223	if (choice == wxYES)
	224	{
	225	//A little hint
	226	ctrl.ctrl->SetCursor(wxCursor(wxCURSOR_HAND));
	227
	228	// Do some rect adjust so it can include the dropdown list
	229	// This adjust isn't pretty, but it works fine on all three paltforms.
	230	// Looking forward to a better solution
	231	int h = rect.GetHeight();
	232	rect.SetHeight(h * 4);
	233	}
	234	}
	235
	236	// cut off "wx" and change the name into lowercase.
	237	// e.g. wxButton will have a name of "button" at the end
	238	ctrl.name.StartsWith(wxT("wx"), &(ctrl.name));
	239	ctrl.name.MakeLower();
	240
	241	// take the screenshot
	242	Capture(bitmap, rect, (choice == wxYES)?5:0);
	243
	244	if (choice == wxYES) ctrl.ctrl->SetCursor(wxNullCursor);
	245
	246	if (ctrl.flag & AJ_RegionAdjust)
	247	PutBack(ctrl.ctrl);
	248
	249	return true;
	250	}
	251
	252	/* static */
	253	bool AutoCaptureMechanism::Union(wxBitmap* top, wxBitmap* bottom, wxBitmap* result)
	254	{
	255	int w1, w2, h1, h2, w, h;
	256	w1 = top->GetWidth();
	257	w2 = bottom->GetWidth();
	258	h1 = top->GetHeight();
	259	h2 = bottom->GetHeight();
	260
	261	const int gap_between = 20;
	262
	263	w = (w1 >= w2) ? w1 : w2;
	264	h = h1 + h2 + gap_between;
	265
	266	result->Create(w, h);
	267
	268	wxMemoryDC dstDC;
	269	dstDC.SelectObject((*result));
	270
	271	dstDC.SetBrush(*wxWHITE_BRUSH);
	272	dstDC.Clear();
	273	dstDC.DrawBitmap((*top), 0, 0);
	274	dstDC.DrawBitmap((*bottom), 0, h1 + gap_between);
	275
	276	dstDC.SelectObject(wxNullBitmap);
	277
	278	return true;
	279	}
	280
	281	wxRect AutoCaptureMechanism::GetRect(wxWindow* ctrl, int flag)
	282	{
	283	if( (!(m_flag & AJ_DisableRegionAdjust) && (flag & AJ_RegionAdjust))
	284	\|\| (m_flag & AJ_AlwaysRegionAdjust) )
	285	{
	286	wxWindow * parent = ctrl->GetParent();
	287	wxSizer * sizer = parent->GetSizer();
	288
	289	//The assertion won't fail if controls are still managed by wxSizer, and it's unlikely to
	290	//change in the future.
	291	wxASSERT_MSG(sizer,
	292	"The GUI that AutoCaptureMechanism working with doesn't manage controls with wxSizer");
	293
	294	sizer->Detach(ctrl);
	295
	296	/*
	297	+---------+-----------+---------+
	298	\| 0 \| label \| 1 \|
	299	+---------+-----------+---------+
	300	\| label \| ctrl \| label \|
	301	+---------+-----------+---------+
	302	\| 2 \| label \| 3 \|
	303	+---------+-----------+---------+
	304	*/
	305
	306	m_grid = new wxFlexGridSizer(3, 3, m_margin, m_margin);
	307
	308	wxStaticText* l[4];
	309
	310	for (int i = 0; i < 4; ++i)
	311	l[i] = new wxStaticText(parent, wxID_ANY, wxT(" "));
	312
	313	m_grid->Add(l[0]);
	314	m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
	315	m_grid->Add(l[1]);
	316	m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
	317	m_grid->Add(ctrl, 1, wxEXPAND);
	318	m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
	319	m_grid->Add(l[2]);
	320	m_grid->Add(new wxStaticText(parent, wxID_ANY, wxT(" ")));
	321	m_grid->Add(l[3]);
	322
	323	sizer->Add(m_grid);
	324	parent->SetSizer(sizer);
	325	parent->Layout();
	326
	327	parent->Refresh();
	328	wxYield();
	329
	330	return wxRect(l[0]->GetScreenRect().GetBottomRight(),
	331	l[3]->GetScreenRect().GetTopLeft());
	332	}
	333	else
	334	{
	335	return ctrl->GetScreenRect().Inflate(m_margin);
	336	}
	337	}
	338
	339	void AutoCaptureMechanism::PutBack(wxWindow * ctrl)
	340	{
	341	if(!m_grid) return;
	342
	343	m_grid->Detach(ctrl);
	344
	345	wxSizerItemList children = m_grid->GetChildren();
	346
	347	for (wxSizerItemList::iterator it = children.begin(); it != children.end(); ++it)
	348	{
	349	wxSizerItem* item = *it;
	350	if (item->IsWindow()) delete (*it)->GetWindow();
	351	}
	352
	353	wxSizer * sizer = ctrl->GetParent()->GetSizer();
	354
	355	//The assertion won't fail if controls are still managed by wxSizer, and it's unlikely to
	356	//change in the future.
	357	wxASSERT_MSG(sizer,
	358	"The GUI that AutoCaptureMechanism working with doesn't manage controls with wxSizer");
	359
	360	sizer->Detach(m_grid);
	361	delete m_grid;
	362	m_grid = NULL;
	363
	364	sizer->Add(ctrl);
	365	}
	366