static int readDNComponent( INOUT STREAM *stream,
INOUT DN_COMPONENT **dnComponentListPtrPtr )
{
int rdnLength, iterationCount, status;
/* Read the start of the RDN */
status = readSet( stream, &rdnLength );
if( cryptStatusError( status ) )
return( status );
/* Read each RDN component */
for( iterationCount = 0;
rdnLength > 0 && iterationCount < FAILSAFE_ITERATIONS_MED;
iterationCount++ )
{
const int rdnStart = stell( stream );
REQUIRES( rdnStart > 0 && rdnStart < MAX_INTLENGTH_SHORT );
status = readRDNcomponent( stream, dnComponentListPtrPtr,
rdnLength );
if( cryptStatusError( status ) && status != OK_SPECIAL )
return( status );
rdnLength -= stell( stream ) - rdnStart;
}
if( rdnLength < 0 || iterationCount >= FAILSAFE_ITERATIONS_MED )
return( CRYPT_ERROR_BADDATA );
return( CRYPT_OK );
}
kitchenFrame::kitchenFrame(wxWindow* parent,wxWindowID id)
{
vers << AutoVersion::MAJOR << _T(".") << AutoVersion::MINOR << _T(".") << AutoVersion::BUILD;
readSet();
//(*Initialize(kitchenFrame)
wxMenuItem* MenuItem2;
wxMenuItem* MenuItem1;
wxFlexGridSizer* FlexGridSizer8;
wxGridSizer* GridSizer1;
wxFlexGridSizer* FlexGridSizer1;
wxFlexGridSizer* FlexGridSizer2;
wxMenu* Menu1;
wxGridSizer* GridSizer2;
wxFlexGridSizer* FlexGridSizer7;
wxFlexGridSizer* FlexGridSizer4;
wxFlexGridSizer* FlexGridSizer6;
wxFlexGridSizer* FlexGridSizer3;
wxBoxSizer* BoxSizer1;
wxMenuBar* MenuBar1;
wxMenu* Menu2;
wxFlexGridSizer* FlexGridSizer5;
Create(parent, id, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE, _T("id"));
GridSizer1 = new wxGridSizer(1, 1, 0, 0);
Notebook1 = new wxNotebook(this, ID_NOTEBOOK1, wxDefaultPosition, wxDefaultSize, 0, _T("ID_NOTEBOOK1"));
Panel1 = new wxPanel(Notebook1, ID_PANEL1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL, _T("ID_PANEL1"));
GridSizer2 = new wxGridSizer(0, 1, 0, 0);
FlexGridSizer1 = new wxFlexGridSizer(1, 4, 0, 0);
FlexGridSizer4 = new wxFlexGridSizer(2, 2, 0, 0);
FlexGridSizer2 = new wxFlexGridSizer(0, 3, 0, 0);
StaticText1 = new wxStaticText(Panel1, ID_STATICTEXT1, _("Pending items:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT1"));
wxFont StaticText1Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
StaticText1->SetFont(StaticText1Font);
FlexGridSizer2->Add(StaticText1, 1, wxALL|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
Button5 = new wxButton(Panel1, ID_BUTTON5, _("Refresh"), wxDefaultPosition, wxSize(90,50), 0, wxDefaultValidator, _T("ID_BUTTON5"));
wxFont Button5Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button5->SetFont(Button5Font);
FlexGridSizer2->Add(Button5, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer4->Add(FlexGridSizer2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
BoxSizer1 = new wxBoxSizer(wxHORIZONTAL);
ToggleButton1 = new wxToggleButton(Panel1, ID_TOGGLEBUTTON1, _("Qty"), wxDefaultPosition, wxSize(80,50), 0, wxDefaultValidator, _T("ID_TOGGLEBUTTON1"));
ToggleButton1->SetValue(true);
wxFont ToggleButton1Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
ToggleButton1->SetFont(ToggleButton1Font);
BoxSizer1->Add(ToggleButton1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
ToggleButton2 = new wxToggleButton(Panel1, ID_TOGGLEBUTTON2, _("Time"), wxDefaultPosition, wxSize(80,50), 0, wxDefaultValidator, _T("ID_TOGGLEBUTTON2"));
wxFont ToggleButton2Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
ToggleButton2->SetFont(ToggleButton2Font);
BoxSizer1->Add(ToggleButton2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer4->Add(BoxSizer1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
ListBox2 = new wxSimpleHtmlListBox(Panel1, ID_HTMLLISTBOX1, wxDefaultPosition, wxSize(250,555), 0, 0, wxSUNKEN_BORDER, wxDefaultValidator, _T("ID_HTMLLISTBOX1"));
FlexGridSizer4->Add(ListBox2, 1, wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
FlexGridSizer7 = new wxFlexGridSizer(30, 1, 0, 0);
ListBox3 = new wxSimpleHtmlListBox(Panel1, ID_HTMLLISTBOX2, wxDefaultPosition, wxSize(250,435), 0, 0, wxSUNKEN_BORDER, wxDefaultValidator, _T("ID_HTMLLISTBOX2"));
FlexGridSizer7->Add(ListBox3, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
Button3 = new wxButton(Panel1, ID_BUTTON3, _("UP"), wxDefaultPosition, wxSize(80,50), 0, wxDefaultValidator, _T("ID_BUTTON3"));
wxFont Button3Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button3->SetFont(Button3Font);
FlexGridSizer7->Add(Button3, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);
Button4 = new wxButton(Panel1, ID_BUTTON4, _("DOWN"), wxDefaultPosition, wxSize(80,50), 0, wxDefaultValidator, _T("ID_BUTTON4"));
wxFont Button4Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button4->SetFont(Button4Font);
FlexGridSizer7->Add(Button4, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer4->Add(FlexGridSizer7, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
FlexGridSizer1->Add(FlexGridSizer4, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
FlexGridSizer1->Add(-1,-1,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer5 = new wxFlexGridSizer(3, 1, 0, 0);
StaticText2 = new wxStaticText(Panel1, ID_STATICTEXT2, _("Selected items info:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT2"));
wxFont StaticText2Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
StaticText2->SetFont(StaticText2Font);
FlexGridSizer5->Add(StaticText2, 1, wxALL|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
StaticText9 = new wxStaticText(Panel1, ID_STATICTEXT9, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT9"));
wxFont StaticText9Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
StaticText9->SetFont(StaticText9Font);
FlexGridSizer5->Add(StaticText9, 1, wxALL|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
ListBox4 = new wxSimpleHtmlListBox(Panel1, ID_HTMLLISTBOX3, wxDefaultPosition, wxSize(250,429), 0, 0, wxSUNKEN_BORDER, wxDefaultValidator, _T("ID_HTMLLISTBOX3"));
FlexGridSizer5->Add(ListBox4, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button1 = new wxButton(Panel1, ID_BUTTON1, _("UP"), wxDefaultPosition, wxSize(80,50), 0, wxDefaultValidator, _T("ID_BUTTON1"));
wxFont Button1Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button1->SetFont(Button1Font);
FlexGridSizer5->Add(Button1, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);
Button2 = new wxButton(Panel1, ID_BUTTON2, _("DOWN"), wxDefaultPosition, wxSize(80,50), 0, wxDefaultValidator, _T("ID_BUTTON2"));
wxFont Button2Font(14,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button2->SetFont(Button2Font);
FlexGridSizer5->Add(Button2, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer1->Add(FlexGridSizer5, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
FlexGridSizer6 = new wxFlexGridSizer(2, 1, 0, 0);
FlexGridSizer3 = new wxFlexGridSizer(0, 3, 0, 0);
FlexGridSizer6->Add(FlexGridSizer3, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer8 = new wxFlexGridSizer(3, 1, 0, 0);
FlexGridSizer8->Add(20,327,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
TextCtrl1 = new wxTextCtrl(Panel1, ID_TEXTCTRL1, wxEmptyString, wxDefaultPosition, wxSize(200,130), wxTE_AUTO_SCROLL|wxTE_MULTILINE|wxTE_RICH2, wxDefaultValidator, _T("ID_TEXTCTRL1"));
FlexGridSizer8->Add(TextCtrl1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
TextCtrl2 = new wxTextCtrl(Panel1, ID_TEXTCTRL2, wxEmptyString, wxDefaultPosition, wxSize(200,50), wxTE_AUTO_SCROLL|wxTE_MULTILINE, wxDefaultValidator, _T("ID_TEXTCTRL2"));
FlexGridSizer8->Add(TextCtrl2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button6 = new wxButton(Panel1, ID_BUTTON6, _("Send"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON6"));
FlexGridSizer8->Add(Button6, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer6->Add(FlexGridSizer8, 1, wxALL|wxALIGN_BOTTOM|wxALIGN_CENTER_HORIZONTAL, 5);
FlexGridSizer1->Add(FlexGridSizer6, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
GridSizer2->Add(FlexGridSizer1, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Panel1->SetSizer(GridSizer2);
GridSizer2->Fit(Panel1);
GridSizer2->SetSizeHints(Panel1);
Notebook1->AddPage(Panel1, _("Pending items"), false);
GridSizer1->Add(Notebook1, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
SetSizer(GridSizer1);
MenuBar1 = new wxMenuBar();
Menu1 = new wxMenu();
MenuItem1 = new wxMenuItem(Menu1, idMenuQuit, _("Quit\tAlt-F4"), _("Quit the application"), wxITEM_NORMAL);
Menu1->Append(MenuItem1);
MenuBar1->Append(Menu1, _("&File"));
Menu3 = new wxMenu();
MenuItem3 = new wxMenuItem(Menu3, ID_MENUITEM1, _("General"), wxEmptyString, wxITEM_NORMAL);
Menu3->Append(MenuItem3);
MenuBar1->Append(Menu3, _("Settings"));
Menu2 = new wxMenu();
MenuItem2 = new wxMenuItem(Menu2, idMenuAbout, _("About\tF1"), _("Show info about this application"), wxITEM_NORMAL);
Menu2->Append(MenuItem2);
MenuBar1->Append(Menu2, _("Help"));
SetMenuBar(MenuBar1);
StatusBar1 = new wxStatusBar(this, ID_STATUSBAR1, 0, _T("ID_STATUSBAR1"));
int __wxStatusBarWidths_1[2] = { -10, -10 };
int __wxStatusBarStyles_1[2] = { wxSB_NORMAL, wxSB_NORMAL };
StatusBar1->SetFieldsCount(2,__wxStatusBarWidths_1);
StatusBar1->SetStatusStyles(2,__wxStatusBarStyles_1);
SetStatusBar(StatusBar1);
Timer1.SetOwner(this, ID_TIMER1);
Timer1.Start(60000, false);
GridSizer1->Fit(this);
GridSizer1->SetSizeHints(this);
Connect(ID_BUTTON5,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnButton5Click);
Connect(ID_TOGGLEBUTTON1,wxEVT_COMMAND_TOGGLEBUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnToggleButton1Toggle);
Connect(ID_TOGGLEBUTTON2,wxEVT_COMMAND_TOGGLEBUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnToggleButton2Toggle);
Connect(ID_HTMLLISTBOX1,wxEVT_COMMAND_LISTBOX_SELECTED,(wxObjectEventFunction)&kitchenFrame::OnListBox2Select);
Connect(ID_HTMLLISTBOX2,wxEVT_COMMAND_LISTBOX_SELECTED,(wxObjectEventFunction)&kitchenFrame::OnListBox3Select);
Connect(ID_BUTTON3,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnButton3Click);
Connect(ID_BUTTON4,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnButton4Click);
Connect(ID_HTMLLISTBOX3,wxEVT_COMMAND_LISTBOX_SELECTED,(wxObjectEventFunction)&kitchenFrame::OnListBox4Select);
Connect(ID_BUTTON1,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnButton1Click);
Connect(ID_BUTTON2,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnButton2Click);
Connect(ID_BUTTON6,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&kitchenFrame::OnButton6Click);
Connect(ID_NOTEBOOK1,wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,(wxObjectEventFunction)&kitchenFrame::OnNotebook1PageChanged);
Connect(idMenuQuit,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&kitchenFrame::OnQuit);
Connect(ID_MENUITEM1,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&kitchenFrame::OnSettingsMenuSelected);
Connect(idMenuAbout,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&kitchenFrame::OnAbout);
Connect(ID_TIMER1,wxEVT_TIMER,(wxObjectEventFunction)&kitchenFrame::OnTimer1Trigger);
//*)
SetTitle(_T("Estescook ") + vers);
// Connect(ID_HTMLLISTBOX3,wxEVT_COMMAND_LISTBOX_SELECTED,(wxObjectEventFunction)&kitchenFrame::OnListSelected);
href = false;
conn = new mysqlpp::Connection(false);
connect_to_db();
SocketClient1 = new wxSocketClient();
SocketClient1->SetEventHandler(*this, SOCKET_ID);
SocketClient1->SetNotify(wxSOCKET_CONNECTION_FLAG |
wxSOCKET_INPUT_FLAG |
wxSOCKET_LOST_FLAG);
SocketClient1->Notify(true);
connectToServer();
fillMain();
fillPanels();
GridSizer1->Fit(this);
GridSizer1->SetSizeHints(this);
}
/**
* Given a set of values, times how long it takes to find if a specified target
* value can be made by summing a subset of the given set of values.
*
* Command line args:
* argv[1] - a file of numbers that are in our set of values. The first line of
* the file is the number of values in the file.
* argv[2] - a file of 30 numbers that are the targets that we try to reach
* with a subset of the values in argv[1]
*
* Compile: gcc proj1.c -fopenmp -o proj1
* Run: ./proj1 set_I_filename targets_filename
*
* Authors: Gaurav Luthria <*****@*****.**>
* Rajan Patel <*****@*****.**>
* Michael Bishoff <*****@*****.**>
*/
int main(int argc, char* argv[]) {
// Check if command line args are valid
if (argc != 3) {
printf("ERROR: Command line arguments are <set_I_filename> ");
printf("<targets_filename>\n");
return 1;
}
// Initializes I, the set of values, and the list of targets that we use
// to see if a subset of I sums to the value of a target
int* I = readSet(argv[1]);
int* targets = readTargets(argv[2]);
// Determines the number of columns needed in the Q table
numCols = getNumColumns(I);
// Allocates space for the Q table
int** Q = malloc(sizeof(*Q)*numRows);
for (int i = 0; i < numRows; i++) {
Q[i] = malloc(sizeof(*(Q[i]))*numCols);
}
double totalTime = 0;
for (int i = 0; i < NUM_TARGETS; i++) {
clearQMatrix(Q);
double startTime = omp_get_wtime();
//clock_t startTime = clock();
int solutionExists = findSolution(I, Q, targets[i]);
double endTime = omp_get_wtime();
//clock_t endTime = clock();
totalTime += (double) (endTime - startTime);
// Uncomment this to see the reconstructed solution!
/*
printf("%d: ", targets[i]);
// If there's a solution, print it
if (solutionExists) {
// Uncomment this to see the Q table!
// printPretty(I, Q);
reconstructSolution(I, Q, targets[i]);
} else {
printf("NO SOUTION EXISTS! ");
}
*/
}
printf("Average Time: %f\n", (totalTime / NUM_TARGETS));
printf("Total Time: %f\n", totalTime);
// Freeeee
free(I);
for (int i = 0; i < numRows; i++) {
free(Q[i]);
}
free(Q);
return 0;
}
void Plink::driverSCREEPI()
{
///////////////////////////////
// Gene-based epistasis
//////////////////////////////////////////
// Case-control samples only
affCoding(*this);
//////////////////////////////////////////
// SNP-major mode analysis
if (!par::SNP_major)
Ind2SNP();
//////////////////////////////////////////
// Requires that sets have been speciefied
if (par::set_test) readSet();
else error("Need to specify genes with --set {filename} when using --genepi\n");
//////////////////
// SET statistics
Set S(snpset);
//////////////////////////////////////////////
// Prune SET (0-sized sets, MAF==0 SNPs, etc)
S.pruneSets(*this);
int ns = snpset.size();
if (ns < 2)
error("Need to specify at least two fully valid sets\n");
int n = 0;
int ncase = 0;
/////////////////////////////////////////////////////////
// Prune based on VIF
string original_outfile = par::output_file_name;
// Case-control? Prune cases and controls together...
if (!par::epi_caseonly)
{
printLOG("\nConsidering cases and controls: ");
setFlags(false);
vector<Individual*>::iterator person = sample.begin();
while ( person != sample.end() )
{
if ( ! (*person)->missing )
{
(*person)->flag = true;
n++;
}
person++;
}
par::output_file_name += ".all";
S.pruneMC(*this,false,par::vif_threshold);
//S.pruneMC(*this,false,1000);
}
// Case-only? Prune cases only...
else
{
printLOG("\nConsidering cases: ");
setFlags(false);
vector<Individual*>::iterator person = sample.begin();
while ( person != sample.end() )
{
if ( (*person)->aff && ! (*person)->missing )
{
(*person)->flag = true;
ncase++;
}
person++;
n++;
}
par::output_file_name += ".case";
S.pruneMC(*this,false,par::vif_threshold);
//S.pruneMC(*this,false,1000);
}
par::output_file_name = original_outfile;
// Write finalized set
ofstream SET1, SET2;
string f = par::output_file_name + ".all.set.in";
printLOG("Writing combined pruned-in set file to [ " + f + " ]\n");
SET1.open(f.c_str(),ios::out);
f = par::output_file_name + ".all.set.out";
printLOG("Writing combined pruned-out set file to [ " + f + " ]\n");
SET2.open(f.c_str(),ios::out);
for (int s=0; s<snpset.size(); s++)
{
int nss = snpset[s].size();
SET1 << setname[s] << "\n";
SET2 << setname[s] << "\n";
for (int j=0; j<nss; j++)
{
if (S.cur[s][j])
SET1 << locus[snpset[s][j]]->name << "\n";
else
SET2 << locus[snpset[s][j]]->name << "\n";
}
SET1 << "END\n\n";
SET2 << "END\n\n";
}
SET1.close();
SET2.close();
// Prune empty sets once more:
S.pruneSets(*this);
ns = snpset.size();
if (ns < 2)
error("Need to specify at least two fully valid sets\n");
////////////////////////////////
// Set up permutation structure
// Specialized (i.e. cannot use Perm class) as this
// requires a block-locus permutation
// First block is fixed
vector<vector<int> > blperm(ns);
vector<vector<int> > blperm_case(ns);
vector<vector<int> > blperm_control(ns);
for (int i=0; i<ns; i++)
{
// A slot for each individual per locus
for (int j=0; j<n; j++)
if ( ! sample[j]->missing )
blperm[i].push_back(j);
// A slot for each individual per locus
for (int j=0; j<n; j++)
if ( ! sample[j]->missing && sample[j]->aff )
blperm_case[i].push_back(j);
// A slot for each individual per locus
for (int j=0; j<n; j++)
if ( ! sample[j]->missing && !sample[j]->aff )
blperm_control[i].push_back(j);
}
////////////////////////////////////////////
// Open file and print header for results
ofstream EPI(f.c_str(), ios::out);
EPI.open(f.c_str(), ios::out);
EPI.precision(4);
////////////////////////////////////////
// Analysis (calls genepi functions)
if (!par::epi_caseonly)
CCA_logit(false,blperm,S,*this);
else
CCA_caseonly(false,blperm_case,S,*this);
if (!par::permute)
return;
if (!par::silent)
cout << "\n";
} // End of screepi
int main() {
reset();
createSet();
readSet();
return 0;
}
static int readRsaPrivateKeyOld( INOUT STREAM *stream,
INOUT CONTEXT_INFO *contextInfoPtr )
{
CRYPT_ALGO_TYPE cryptAlgo;
PKC_INFO *rsaKey = contextInfoPtr->ctxPKC;
const int startPos = stell( stream );
int length, endPos, iterationCount, status;
assert( isWritePtr( stream, sizeof( STREAM ) ) );
assert( isWritePtr( contextInfoPtr, sizeof( CONTEXT_INFO ) ) );
REQUIRES( contextInfoPtr->type == CONTEXT_PKC && \
contextInfoPtr->capabilityInfo->cryptAlgo == CRYPT_ALGO_RSA );
/* Skip the PKCS #8 wrapper. When we read the OCTET STRING
encapsulation we use MIN_PKCSIZE_THRESHOLD rather than MIN_PKCSIZE
so that a too-short key will get to readBignumChecked(), which
returns an appropriate error code */
readSequence( stream, &length ); /* Outer wrapper */
readShortInteger( stream, NULL ); /* Version */
status = readAlgoID( stream, &cryptAlgo, ALGOID_CLASS_PKC );
if( cryptStatusError( status ) || cryptAlgo != CRYPT_ALGO_RSA )
return( CRYPT_ERROR_BADDATA );
status = readOctetStringHole( stream, NULL,
( 2 * MIN_PKCSIZE_THRESHOLD ) + \
( 5 * ( MIN_PKCSIZE_THRESHOLD / 2 ) ),
DEFAULT_TAG );
if( cryptStatusError( status ) ) /* OCTET STRING encapsulation */
return( status );
/* Read the header */
readSequence( stream, NULL );
status = readShortInteger( stream, NULL );
if( cryptStatusError( status ) )
return( status );
/* Read the RSA key components, skipping n and e if we've already got
them via the associated public key/certificate */
if( BN_is_zero( &rsaKey->rsaParam_n ) )
{
status = readBignumChecked( stream, &rsaKey->rsaParam_n,
RSAPARAM_MIN_N, RSAPARAM_MAX_N,
NULL );
if( cryptStatusOK( status ) )
status = readBignum( stream, &rsaKey->rsaParam_e,
RSAPARAM_MIN_E, RSAPARAM_MAX_E,
&rsaKey->rsaParam_n );
}
else
{
readUniversal( stream );
status = readUniversal( stream );
}
if( cryptStatusOK( status ) )
{
/* d isn't used so we skip it */
status = readUniversal( stream );
}
if( cryptStatusOK( status ) )
status = readBignum( stream, &rsaKey->rsaParam_p,
RSAPARAM_MIN_P, RSAPARAM_MAX_P,
&rsaKey->rsaParam_n );
if( cryptStatusOK( status ) )
status = readBignum( stream, &rsaKey->rsaParam_q,
RSAPARAM_MIN_Q, RSAPARAM_MAX_Q,
&rsaKey->rsaParam_n );
if( cryptStatusOK( status ) )
status = readBignum( stream, &rsaKey->rsaParam_exponent1,
RSAPARAM_MIN_EXP1, RSAPARAM_MAX_EXP1,
&rsaKey->rsaParam_n );
if( cryptStatusOK( status ) )
status = readBignum( stream, &rsaKey->rsaParam_exponent2,
RSAPARAM_MIN_EXP2, RSAPARAM_MAX_EXP2,
&rsaKey->rsaParam_n );
if( cryptStatusOK( status ) )
status = readBignum( stream, &rsaKey->rsaParam_u,
RSAPARAM_MIN_U, RSAPARAM_MAX_U,
&rsaKey->rsaParam_n );
if( cryptStatusError( status ) )
return( status );
/* Check whether there are any attributes present */
if( stell( stream ) >= startPos + length )
return( CRYPT_OK );
/* Read the attribute wrapper */
status = readConstructed( stream, &length, 0 );
if( cryptStatusError( status ) )
return( status );
endPos = stell( stream ) + length;
/* Read the collection of attributes. Unlike any other key-storage
format, PKCS #8 stores the key usage information as an X.509
attribute alongside the encrypted private key data so we have to
process whatever attributes may be present in order to find the
keyUsage (if there is any) in order to set the object action
permissions */
for( iterationCount = 0;
stell( stream ) < endPos && \
iterationCount < FAILSAFE_ITERATIONS_MED;
iterationCount++ )
{
BYTE oid[ MAX_OID_SIZE + 8 ];
int oidLength, actionFlags, value;
/* Read the attribute. Since there's only one attribute type that
we can use, we hardcode the read in here rather than performing a
general-purpose attribute read */
readSequence( stream, NULL );
status = readEncodedOID( stream, oid, MAX_OID_SIZE, &oidLength,
BER_OBJECT_IDENTIFIER );
if( cryptStatusError( status ) )
return( status );
/* If it's not a key-usage attribute, we can't do much with it */
if( oidLength != sizeofOID( OID_X509_KEYUSAGE ) || \
memcmp( oid, OID_X509_KEYUSAGE, oidLength ) )
{
status = readUniversal( stream );
if( cryptStatusError( status ) )
return( status );
continue;
}
/* Read the keyUsage attribute and convert it into cryptlib action
permissions */
readSet( stream, NULL );
status = readBitString( stream, &value );
if( cryptStatusError( status ) )
return( status );
actionFlags = ACTION_PERM_NONE;
if( value & ( KEYUSAGE_SIGN | KEYUSAGE_CA ) )
{
actionFlags |= MK_ACTION_PERM( MESSAGE_CTX_SIGN, \
ACTION_PERM_ALL ) | \
MK_ACTION_PERM( MESSAGE_CTX_SIGCHECK, \
ACTION_PERM_ALL );
}
if( value & KEYUSAGE_CRYPT )
{
actionFlags |= MK_ACTION_PERM( MESSAGE_CTX_ENCRYPT, \
ACTION_PERM_ALL ) | \
MK_ACTION_PERM( MESSAGE_CTX_DECRYPT, \
ACTION_PERM_ALL );
}
#if 0 /* 11/6/13 Windows sets these flags to what are effectively
gibberish values (dataEncipherment for a signing key,
digitalSignature for an encryption key) so in order
to be able to use the key we have to ignore the keyUsage
settings, in the same way that every other application
seems to */
if( actionFlags == ACTION_PERM_NONE )
return( CRYPT_ERROR_NOTAVAIL );
status = krnlSendMessage( contextInfoPtr->objectHandle,
IMESSAGE_SETATTRIBUTE, &actionFlags,
CRYPT_IATTRIBUTE_ACTIONPERMS );
if( cryptStatusError( status ) )
return( status );
#else
assert( actionFlags != ACTION_PERM_NONE ); /* Warn in debug mode */
#endif /* 0 */
}
ENSURES( iterationCount < FAILSAFE_ITERATIONS_MED );
return( CRYPT_OK );
}
static int readGeneralInfoAttribute( INOUT STREAM *stream,
INOUT CMP_PROTOCOL_INFO *protocolInfo )
{
BYTE oid[ MAX_OID_SIZE + 8 ];
int length, status;
assert( isWritePtr( stream, sizeof( STREAM ) ) );
assert( isWritePtr( protocolInfo, sizeof( CMP_PROTOCOL_INFO ) ) );
/* Read the attribute. Since there are only two attribute types that we
use, we hardcode the read in here rather than performing a general-
purpose attribute read */
readSequence( stream, NULL );
status = readEncodedOID( stream, oid, MAX_OID_SIZE, &length,
BER_OBJECT_IDENTIFIER );
if( cryptStatusError( status ) )
return( status );
/* Process the cryptlib presence-check value */
if( length == sizeofOID( OID_CRYPTLIB_PRESENCECHECK ) && \
!memcmp( oid, OID_CRYPTLIB_PRESENCECHECK, length ) )
{
/* The other side is running cryptlib, we can make some common-sense
assumptions about its behaviour */
protocolInfo->isCryptlib = TRUE;
return( readUniversal( stream ) ); /* Attribute */
}
/* Check for the ESSCertID, which fixes CMP's broken certificate
identification mechanism */
if( length == sizeofOID( OID_ESS_CERTID ) && \
!memcmp( oid, OID_ESS_CERTID, length ) )
{
BYTE certID[ CRYPT_MAX_HASHSIZE + 8 ];
int certIDsize, endPos;
/* Extract the certificate hash from the ESSCertID */
readSet( stream, NULL ); /* Attribute */
readSequence( stream, NULL ); /* SigningCerts */
readSequence( stream, NULL ); /* Certs */
status = readSequence( stream, &length ); /* ESSCertID */
if( cryptStatusError( status ) )
return( status );
endPos = stell( stream ) + length;
status = readOctetString( stream, certID, &certIDsize,
KEYID_SIZE, KEYID_SIZE );
if( cryptStatusError( status ) )
return( status );
if( protocolInfo->certIDsize != KEYID_SIZE || \
memcmp( certID, protocolInfo->certID, KEYID_SIZE ) )
{
/* The certificate used for authentication purposes has changed,
remember the new certID */
memcpy( protocolInfo->certID, certID, KEYID_SIZE );
protocolInfo->certIDsize = KEYID_SIZE;
protocolInfo->certIDchanged = TRUE;
}
if( stell( stream ) < endPos )
{
/* Skip the issuerSerial if there's one present. We can't
really do much with it in this form without rewriting it into
the standard issuerAndSerialNumber, but in any case we don't
need it because we've already got the certificate ID */
status = readUniversal( stream );
}
return( status );
}
/* It's something that we don't recognise, skip it */
return( readUniversal( stream ) );
}
static int processCertWrapper( INOUT STREAM *stream,
OUT_LENGTH_SHORT_Z int *objectOffset,
OUT_DATALENGTH_Z int *objectLength,
IN_DATALENGTH_Z const int objectStartPos )
{
static const CMS_CONTENT_INFO FAR_BSS oidInfoSignedData = { 1, 3 };
static const OID_INFO FAR_BSS signedDataOIDinfo[] = {
{ OID_CMS_SIGNEDDATA, CRYPT_OK, &oidInfoSignedData },
{ NULL, 0 }, { NULL, 0 }
};
static const OID_INFO FAR_BSS dataOIDinfo[] = {
{ OID_CMS_DATA, CRYPT_OK, NULL },
{ NULL, 0 }, { NULL, 0 }
};
long length;
int setLength, localLength, offset DUMMY_INIT, status;
assert( isWritePtr( stream, sizeof( STREAM ) ) );
assert( isWritePtr( objectOffset, sizeof( int ) ) );
assert( isWritePtr( objectLength, sizeof( int ) ) );
REQUIRES( objectStartPos >= 0 && objectStartPos < MAX_BUFFER_SIZE );
/* Clear return values */
*objectOffset = *objectLength = 0;
/* Read the SignedData wrapper */
sseek( stream, objectStartPos );
status = readCMSheader( stream, signedDataOIDinfo,
FAILSAFE_ARRAYSIZE( signedDataOIDinfo, OID_INFO ),
&length, READCMS_FLAG_NONE );
if( cryptStatusError( status ) )
return( status );
/* Read the SET OF DigestAlgorithmIdentifier, empty for a pure
certificate chain, nonempty for signed data or buggy certificate
chains */
status = readSet( stream, &setLength );
if( cryptStatusOK( status ) && setLength > 0 )
status = sSkip( stream, setLength, MAX_INTLENGTH_SHORT );
if( cryptStatusError( status ) )
return( status );
/* Read the ContentInfo information */
status = readCMSheader( stream, dataOIDinfo,
FAILSAFE_ARRAYSIZE( dataOIDinfo, OID_INFO ),
&length, READCMS_FLAG_INNERHEADER );
if( cryptStatusError( status ) )
return( status );
/* If we've been fed signed data (i.e. the ContentInfo has the content
field present), skip the content to get to the certificate chain */
if( length > 0 )
{
status = sSkip( stream, length, MAX_INTLENGTH_SHORT );
if( cryptStatusError( status ) )
return( status );
}
else
{
/* If we have an indefinite length then there could be up to three
EOCs present (one for each of the SEQUENCE, [0], and OCTET
STRING), which we have to skip. In theory there could be content
present as well but at that point we're going to be replicating
large chunks of the de-enveloping code so we only try and process
zero-length content, created by some buggy browser's cert-export
code (possibly Firefox) */
if( length == CRYPT_UNUSED )
{
int i;
for( i = 0; i < 3; i++ )
{
status = checkEOC( stream );
if( cryptStatusError( status ) )
return( status );
if( !status )
break;
}
}
}
/* We've reached the inner content encapsulation, find out how long the
content (i.e. the chain of certificates) is */
status = getStreamObjectLength( stream, &localLength );
if( cryptStatusOK( status ) )
{
offset = stell( stream );
status = readConstructedI( stream, NULL, 0 );
}
if( cryptStatusError( status ) )
return( status );
/* Adjust for the [0] { ... } wrapper that contains the list of
certificate, returning a pointer to the collection of certificates
without any encapsulation */
localLength -= stell( stream ) - offset;
if( localLength < MIN_CERTSIZE || localLength >= MAX_INTLENGTH )
return( CRYPT_ERROR_BADDATA );
*objectOffset = stell( stream );
*objectLength = localLength;
return( CRYPT_OK );
}
int ReadStarDrop::createLoopThrough(const coDistributedObject *const *meshSet, int numGridSteps,
int numSteps, int *meshIdx)
{
int step, port;
// array for output meshes
const coDistributedObject **newMeshArr = new const coDistributedObject *[numSteps + 1];
newMeshArr[numSteps] = NULL;
const coDistributedObject **newDataArr[NUM_DATA_PORTS],
*const *oldDataObj[NUM_DATA_PORTS];
for (port = 0; port < NUM_DATA_PORTS; port++)
{
oldDataObj[port] = readSet(p_dataIn[port], numGridSteps);
if (oldDataObj[port])
{
newDataArr[port] = new const coDistributedObject *[numSteps + 1];
newDataArr[port][numSteps] = NULL;
}
else
newDataArr[port] = NULL;
}
for (step = 0; step < numSteps; step++)
{
int useIdx = meshIdx[step];
newMeshArr[step] = meshSet[useIdx];
meshSet[useIdx]->incRefCount();
for (port = 0; port < NUM_DATA_PORTS; port++)
{
if (oldDataObj[port])
{
newDataArr[port][step] = oldDataObj[port][useIdx];
oldDataObj[port][useIdx]->incRefCount();
}
}
}
// make the output grid set
char timestepAtt[64];
sprintf(timestepAtt, "0 %d", numSteps - 1);
// make the grid: we MUST NOT copy the old 'TIMESTEP' attribute, because we might have a different
coDoSet *outSet = new coDoSet(p_grid_out->getObjName(), newMeshArr);
if (!outSet || !outSet->objectOk())
return FAIL;
copyAllAttrButTimesteps(outSet, p_grid_in->getCurrentObject());
outSet->addAttribute("TIMESTEP", timestepAtt);
// make the grid: we MUST NOT copy the old 'TIMESTEP' attribute, because we might have a different
for (port = 0; port < NUM_DATA_PORTS; port++)
{
if (oldDataObj[port])
{
coDoSet *outSet = new coDoSet(p_dataOut[port]->getObjName(), newDataArr[port]);
outSet->copyAllAttributes(p_dataIn[port]->getCurrentObject());
p_dataOut[port]->setCurrentObject(outSet);
}
}
p_grid_out->setCurrentObject(outSet);
// clean up
for (step = 0; step < numSteps; step++)
delete newMeshArr[step];
delete[] newMeshArr;
for (port = 0; port < NUM_DATA_PORTS; port++)
if (newDataArr[port])
{
for (step = 0; step < numSteps; step++)
delete newDataArr[port][numSteps];
delete[] newDataArr[port];
}
// do NOT delete [] newDataArr - it's a static array ;-(
return SUCCESS;
}
time_loggerFrame::time_loggerFrame(wxWindow* parent,wxWindowID id)
{
readSet();
std::string version = AutoVersion::FULLVERSION_STRING;
wxString vers;
vers << AutoVersion::MAJOR << _T(".") << AutoVersion::MINOR << _T(".") << AutoVersion::BUILD;
//(*Initialize(time_loggerFrame)
wxGridSizer* GridSizer1;
wxFlexGridSizer* FlexGridSizer1;
wxFlexGridSizer* FlexGridSizer2;
wxGridSizer* GridSizer6;
wxFlexGridSizer* FlexGridSizer4;
wxFlexGridSizer* FlexGridSizer3;
wxBoxSizer* BoxSizer1;
Create(parent, wxID_ANY, _("Time Logger"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE, _T("wxID_ANY"));
{
wxIcon FrameIcon;
FrameIcon.CopyFromBitmap(wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_NORMAL_FILE")),wxART_OTHER));
SetIcon(FrameIcon);
}
GridSizer6 = new wxGridSizer(1, 1, 0, 0);
FlexGridSizer1 = new wxFlexGridSizer(2, 1, 0, 0);
BoxSizer1 = new wxBoxSizer(wxHORIZONTAL);
BoxSizer1->Add(-1,-1,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText1 = new wxStaticText(this, ID_STATICTEXT1, wxEmptyString, wxDefaultPosition, wxSize(180,90), 0, _T("ID_STATICTEXT1"));
wxFont StaticText1Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
StaticText1->SetFont(StaticText1Font);
BoxSizer1->Add(StaticText1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer4 = new wxFlexGridSizer(2, 2, 0, 0);
FlexGridSizer4->Add(30,20,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText2 = new wxStaticText(this, ID_STATICTEXT2, _("Current time:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT2"));
wxFont StaticText2Font(20,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
StaticText2->SetFont(StaticText2Font);
FlexGridSizer4->Add(StaticText2, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer4->Add(30,20,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText3 = new wxStaticText(this, ID_STATICTEXT3, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT3"));
wxFont StaticText3Font(24,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
StaticText3->SetFont(StaticText3Font);
FlexGridSizer4->Add(StaticText3, 1, wxALL|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
BoxSizer1->Add(FlexGridSizer4, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer1->Add(BoxSizer1, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer2 = new wxFlexGridSizer(1, 2, 0, 0);
GridSizer1 = new wxGridSizer(3, 4, 10, 10);
Button1 = new wxButton(this, ID_BUTTON1, _("1"), wxDefaultPosition, wxSize(170,170), 0, wxDefaultValidator, _T("ID_BUTTON1"));
wxFont Button1Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button1->SetFont(Button1Font);
GridSizer1->Add(Button1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button2 = new wxButton(this, ID_BUTTON2, _("2"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON2"));
wxFont Button2Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button2->SetFont(Button2Font);
GridSizer1->Add(Button2, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button3 = new wxButton(this, ID_BUTTON3, _("3"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON3"));
wxFont Button3Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button3->SetFont(Button3Font);
GridSizer1->Add(Button3, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
GridSizer1->Add(-1,-1,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button4 = new wxButton(this, ID_BUTTON4, _("4"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON4"));
wxFont Button4Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button4->SetFont(Button4Font);
GridSizer1->Add(Button4, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button5 = new wxButton(this, ID_BUTTON5, _("5"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON5"));
wxFont Button5Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button5->SetFont(Button5Font);
GridSizer1->Add(Button5, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button6 = new wxButton(this, ID_BUTTON6, _("6"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON6"));
wxFont Button6Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button6->SetFont(Button6Font);
GridSizer1->Add(Button6, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
GridSizer1->Add(-1,-1,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button7 = new wxButton(this, ID_BUTTON7, _("7"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON7"));
wxFont Button7Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button7->SetFont(Button7Font);
GridSizer1->Add(Button7, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button8 = new wxButton(this, ID_BUTTON8, _("8"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON8"));
wxFont Button8Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button8->SetFont(Button8Font);
GridSizer1->Add(Button8, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button9 = new wxButton(this, ID_BUTTON9, _("9"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON9"));
wxFont Button9Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button9->SetFont(Button9Font);
GridSizer1->Add(Button9, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button13 = new wxButton(this, ID_BUTTON13, _("0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON13"));
wxFont Button13Font(56,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button13->SetFont(Button13Font);
GridSizer1->Add(Button13, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer2->Add(GridSizer1, 1, wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 20);
FlexGridSizer3 = new wxFlexGridSizer(5, 1, 0, 0);
Button10 = new wxButton(this, ID_BUTTON10, _("<--"), wxDefaultPosition, wxSize(170,85), 0, wxDefaultValidator, _T("ID_BUTTON10"));
wxFont Button10Font(32,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button10->SetFont(Button10Font);
FlexGridSizer3->Add(Button10, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer3->Add(20,85,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button11 = new wxButton(this, ID_BUTTON11, _("Cancel"), wxDefaultPosition, wxSize(170,85), 0, wxDefaultValidator, _T("ID_BUTTON11"));
wxFont Button11Font(26,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button11->SetFont(Button11Font);
FlexGridSizer3->Add(Button11, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer3->Add(20,85,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
Button12 = new wxButton(this, ID_BUTTON12, _("Enter"), wxDefaultPosition, wxSize(170,170), 0, wxDefaultValidator, _T("ID_BUTTON12"));
wxFont Button12Font(40,wxSWISS,wxFONTSTYLE_NORMAL,wxNORMAL,false,_T("Sans"),wxFONTENCODING_DEFAULT);
Button12->SetFont(Button12Font);
FlexGridSizer3->Add(Button12, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer2->Add(FlexGridSizer3, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 20);
FlexGridSizer1->Add(FlexGridSizer2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
GridSizer6->Add(FlexGridSizer1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
SetSizer(GridSizer6);
StatusBar1 = new wxStatusBar(this, ID_STATUSBAR1, 0, _T("ID_STATUSBAR1"));
int __wxStatusBarWidths_1[1] = { -10 };
int __wxStatusBarStyles_1[1] = { wxSB_NORMAL };
StatusBar1->SetFieldsCount(1,__wxStatusBarWidths_1);
StatusBar1->SetStatusStyles(1,__wxStatusBarStyles_1);
SetStatusBar(StatusBar1);
Timer1.SetOwner(this, ID_TIMER1);
Timer1.Start(100, false);
GridSizer6->Fit(this);
GridSizer6->SetSizeHints(this);
Connect(ID_BUTTON1,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton1Click);
Connect(ID_BUTTON2,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton2Click);
Connect(ID_BUTTON3,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton3Click);
Connect(ID_BUTTON4,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton4Click);
Connect(ID_BUTTON5,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton5Click);
Connect(ID_BUTTON6,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton6Click);
Connect(ID_BUTTON7,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton7Click);
Connect(ID_BUTTON8,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton8Click);
Connect(ID_BUTTON9,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton9Click);
Connect(ID_BUTTON13,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton13Click1);
Connect(ID_BUTTON10,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton12Click);
Connect(ID_BUTTON11,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton13Click);
Connect(ID_BUTTON12,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&time_loggerFrame::OnButton11Click);
Connect(ID_TIMER1,wxEVT_TIMER,(wxObjectEventFunction)&time_loggerFrame::OnTimer1Trigger);
//*)
SetTitle(_T("Time Logger ") + vers);
conn = new mysqlpp::Connection(false);
connect_to_db();
empId = 0;
}
