void kfree_s(void *obj,unsigned int size){
void *page;
struct _bucket_dir *bdir;
Bucket *bdesc,*prev;
page = (void *)(get_pointer((Pointer)obj));
for(bdir = bucket_dir;bdir->size;bdir++){
prev = NULL;
if(bdir->size < size) continue;
for(bdesc = bdir->bucket;bdesc;bdesc = bdesc->next){
if(bdesc->page == page)
goto found;
prev = bdesc;
}
}
panic("Bad address passed to kernel free_s()");
found:
lock();
*((void **)obj) = bdesc->freeptr;
bdesc->refcnt--;
if(bdesc->refcnt == 0){
if((prev && (prev->next != bdesc)) || (!prev && (bdir->bucket != bdesc)))
for(prev = bdir->bucket;prev;prev = prev->next)
if(prev->next == bdesc)
break;
if(prev)
prev->next = bdesc->next;
else{
if(bdir->bucket != bdesc)
panic("malloc bucket corrupted\n");
bdir->bucket = bdesc->next;
}
free_page((Pointer)bdesc->page);
bdesc->next = free_bucket;
free_bucket = bdesc;
}
unlock();
}
static void
generate_focus_event (GdkWindow *window, gboolean focused)
{
GdkEvent *event;
if (focused)
{
gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FOCUSED);
_gdk_mir_display_focus_window (gdk_window_get_display (window), window);
}
else
{
gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FOCUSED, 0);
_gdk_mir_display_unfocus_window (gdk_window_get_display (window), window);
}
event = gdk_event_new (GDK_FOCUS_CHANGE);
event->focus_change.send_event = FALSE;
event->focus_change.in = focused;
send_event (window, get_pointer (window), event);
}
bool SECTREE::InsertEntity(LPENTITY pkEnt)
{
LPSECTREE pkCurTree;
if ((pkCurTree = pkEnt->GetSectree()) == this)
return false;
if (m_set_entity.find(pkEnt) != m_set_entity.end()) {
sys_err("entity %p already exist in this sectree!", get_pointer(pkEnt));
return false;
}
if (pkCurTree)
pkCurTree->m_set_entity.erase(pkEnt);
pkEnt->SetSectree(this);
//pkEnt->UpdateSectree();
m_set_entity.insert(pkEnt);
if (pkEnt->IsType(ENTITY_CHARACTER))
{
LPCHARACTER pkChr = (LPCHARACTER) pkEnt;
if (pkChr->IsPC())
{
IncreasePC();
if (pkCurTree)
pkCurTree->DecreasePC();
}
else if (m_iPCCount > 0 && !pkChr->IsWarp() && !pkChr->IsGoto()) // PC가 아니고 이 곳에 PC가 있다면 Idle event를 시작 시킨다.
{
pkChr->StartStateMachine();
}
}
return true;
}
/*
* Handles the return from a 68k call at the emulator's side.
*/
static uae_u32 REGPARAM2 m68k_return_handler (struct regstruct *regs)
{
ExtendedTrapContext *context;
uae_u32 sp;
/* One trap returning at a time, please! */
uae_sem_wait (&trap_mutex);
/* Get trap context from 68k stack. */
sp = m68k_areg (regs, 7);
context = (struct ExtendedTrapContext *) get_pointer(sp);
sp += sizeof (void *);
m68k_areg (regs, 7) = sp;
/* Get return value from the 68k call. */
context->call68k_retval = m68k_dreg (regs, 0);
/* Update trap's working copy of CPU state. */
context->regs = *regs;
/* Switch back to trap context. */
uae_sem_post (&context->switch_to_trap_sem);
/* Wait for trap context to switch back to us.
*
* It'll do this when the trap handler is done - or when
* the handler wants to call another 68k function. */
uae_sem_wait (&context->switch_to_emu_sem);
/* Use trap's modified 68k state. This will reset the PC, so that
* execution will resume at either the m68k call handler or the
* the exit handler. */
*regs = context->regs;
/* Dummy return value. */
return 0;
}
void CWarMap::AddFlag(BYTE bIdx, DWORD x, DWORD y)
{
if (m_bEnded)
return;
assert(bIdx < 2);
TeamData & r = m_TeamData[bIdx];
if (r.pkChrFlag)
return;
if (x == 0)
{
x = m_kMapInfo.posStart[bIdx].x;
y = m_kMapInfo.posStart[bIdx].y;
}
r.pkChrFlag = CHARACTER_MANAGER::instance().SpawnMob(bIdx == 0 ? warmap::WAR_FLAG_VNUM0 : warmap::WAR_FLAG_VNUM1, m_kMapInfo.lMapIndex, x, y, 0);
sys_log(0, "WarMap::AddFlag %u %p id %u", bIdx, get_pointer(r.pkChrFlag), r.dwID);
r.pkChrFlag->SetPoint(POINT_STAT, r.dwID);
r.pkChrFlag->SetWarMap(this);
}
// If free==0, no new tables will be constructed.
// page_size indicates the size of a page.
// For VADDR_LSO 12 and PT_INDEX_WIDTH 9, this means:
// page_size=0 --> 4KiB
// page_size=1 --> 2MiB
// page_size=2 --> 1GiB
//MLDTODO Rewrite with section nomenclature
int write_entry(pt_t* pt0, uint64_t pts_index, void* dst, unsigned page_size, pt_t** next_table, size_t *free, uint8_t r, uint8_t w, uint8_t x){
pt_t* table = pt0;
pte_t* entry;
int min = page_size;
int max = PTS_INDEX_WIDTH / PT_INDEX_WIDTH;
for(int i=max-1; i>=min; i--){
uint64_t pt_index = get_index_section(pts_index, i);
entry = &(table->entries[pt_index]);
if(i == min){
if(entry->p){ return -32; }
table = construct_pt(next_table);
*free -= 1;
entry->p = 1;
entry->t = 0;
entry->page_p.r = r;
entry->page_p.w = w;
entry->page_p.x = x;
set_pointer(entry, dst);
}else if(entry->p){
table = get_pointer(entry);
}else{
if(*free == 0){ return 0; }
table = construct_pt(next_table);
*free -= 1;
entry->p = entry->t = 1;
set_pointer(entry, table);
}
}
return 1;
}
bool Table::on_button_press_event(GdkEventButton* event)
{
if(event->button==1)
{
int c=on_deck();
if(c!=-1)
{
std::cout<<"Drag begin"<<std::endl;
//Evaluate the grab point on the card
int x,y;
get_pointer(x,y);
card_list[c]->drag_x=x-(2+get_width()/40*c);
card_list[c]->drag_y=y-(get_height()-card_list[c]->card_f->scaled->get_height());
card_list[c]->drag_xb=x;
card_list[c]->drag_yb=y;
card_list[c]->moving=true;
//Copy of the dragged card
card_dragged = new card;
card_dragged = card_list[c];
card_drag=true;
//No card is being pointed
for (card_it=card_list.begin();card_it!=card_list.end();card_it++)
{
(*card_it)->pointed=false;
}
}
}
return true;
}
void* MikMod_realloc(void *data, size_t size)
{
return realloc(data, size);
#if 0
if (data)
{
#if defined __MACH__
void *d = realloc(data, size);
if (d)
{
return d;
}
return 0;
#elif (defined _WIN32 || defined _WIN64) && !defined(_WIN32_WCE)
return _aligned_realloc(data, size, ALIGN_STRIDE);
#else
unsigned char *newPtr = (unsigned char *)realloc(get_pointer(data), size + ALIGN_STRIDE + sizeof(void*));
return align_pointer(newPtr, ALIGN_STRIDE);
#endif
}
return MikMod_malloc(size);
#endif
}
bool CItem::Unequip()
{
if (!m_pOwner || GetCell() < INVENTORY_MAX_NUM)
{
// ITEM_OWNER_INVALID_PTR_BUG
sys_err("%s %u m_pOwner %p, GetCell %d",
GetName(), GetID(), get_pointer(m_pOwner), GetCell());
// END_OF_ITEM_OWNER_INVALID_PTR_BUG
return false;
}
if (this != m_pOwner->GetWear(GetCell() - INVENTORY_MAX_NUM))
{
sys_err("m_pOwner->GetWear() != this");
return false;
}
//½Å±Ô ¸» ¾ÆÀÌÅÛ Á¦°Å½Ã ó¸®
if (IsRideItem())
ClearMountAttributeAndAffect();
if (IsDragonSoul())
{
DSManager::instance().DeactivateDragonSoul(this);
}
else
{
ModifyPoints(false);
}
StopUniqueExpireEvent();
if (-1 != GetProto()->cLimitTimerBasedOnWearIndex)
StopTimerBasedOnWearExpireEvent();
// ACCESSORY_REFINE
StopAccessorySocketExpireEvent();
// END_OF_ACCESSORY_REFINE
m_pOwner->BuffOnAttr_RemoveBuffsFromItem(this);
m_pOwner->SetWear(GetCell() - INVENTORY_MAX_NUM, NULL);
DWORD dwImmuneFlag = 0;
for (int i = 0; i < WEAR_MAX_NUM; i++)
{
LPITEM pItem = m_pOwner->GetWear(i);
if (pItem)
{
SET_BIT(dwImmuneFlag, m_pOwner->GetWear(i)->GetImmuneFlag());
}
}
m_pOwner->SetImmuneFlag(dwImmuneFlag);
m_pOwner->ComputeBattlePoints();
m_pOwner->UpdatePacket();
m_pOwner = NULL;
m_wCell = 0;
m_bEquipped = false;
return true;
}
static void set_bits(pointer &n, std::size_t c)
{
BOOST_INTRUSIVE_INVARIANT_ASSERT(c <= Mask);
n = pointer(std::size_t(get_pointer(n)) | c);
}
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static inline pointee * do_get_pointer(T & x, void const *)
{
return get_pointer(x);
}
SdfAttributeSpecHandle
SdfAttributeSpec::_New(
const SdfRelationshipSpecHandle& owner,
const SdfPath& path,
const std::string& name,
const SdfValueTypeName& typeName,
SdfVariability variability,
bool custom)
{
if (not owner) {
TF_CODING_ERROR("NULL owner");
return TfNullPtr;
}
if (not typeName) {
TF_CODING_ERROR("Cannot create attribute spec <%s> with invalid type",
owner->GetPath().AppendTarget(path).
AppendProperty(TfToken(name)).GetText());
return TfNullPtr;
}
SdfChangeBlock block;
// Determine the path of the relationship target
SdfPath absPath = path.MakeAbsolutePath(owner->GetPath().GetPrimPath());
SdfPath targetPath = owner->GetPath().AppendTarget(absPath);
// Check to make sure that the name is valid
if (not Sdf_ChildrenUtils<Sdf_AttributeChildPolicy>::IsValidName(name)) {
TF_CODING_ERROR(
"Cannot create attribute on %s with invalid name: %s",
targetPath.GetText(), name.c_str());
return TfNullPtr;
}
// Create the relationship target if it doesn't already exist. Note
// that this does not automatically get added to the relationship's
// target path list.
SdfSpecHandle targetSpec = owner->_FindOrCreateTargetSpec(path);
// AttributeSpecs are considered initially to have only required fields
// only if they are not custom.
bool hasOnlyRequiredFields = (not custom);
// Create the relational attribute spec
SdfPath attrPath = targetPath.AppendRelationalAttribute(TfToken(name));
if (not Sdf_ChildrenUtils<Sdf_AttributeChildPolicy>::CreateSpec(
owner->GetLayer(), attrPath, SdfSpecTypeAttribute,
hasOnlyRequiredFields)) {
return TfNullPtr;
}
SdfAttributeSpecHandle spec =
owner->GetLayer()->GetAttributeAtPath(attrPath);
// Avoid expensive dormancy checks in the case of binary-backed data.
SdfAttributeSpec *specPtr = get_pointer(spec);
if (TF_VERIFY(specPtr)) {
specPtr->SetField(SdfFieldKeys->Custom, custom);
specPtr->SetField(SdfFieldKeys->TypeName, typeName.GetAsToken());
specPtr->SetField(SdfFieldKeys->Variability, variability);
}
return spec;
}
static inline PyTypeObject* get_class_object(Ptr const& x)
{
return get_class_object_impl(get_pointer(x));
}
void release()
{
weak = const_cast<void*>(static_cast<void const*>(
get_pointer(p)));
release_ownership(p);
}
template<class U> R const & call(U & u, void const *) const
{
return (get_pointer(u)->*f_);
}
T * get_handle(tagged_node_handle const & handle) const
{
return get_pointer(handle);
}
void CParty::SendMessage(LPCHARACTER ch, BYTE bMsg, DWORD dwArg1, DWORD dwArg2)
{
if (ch->GetParty() != this)
{
sys_err("%s is not member of this party %p", ch->GetName(), this);
return;
}
switch (bMsg)
{
case PM_ATTACK:
break;
case PM_RETURN:
{
TMemberMap::iterator it = m_memberMap.begin();
while (it != m_memberMap.end())
{
TMember & rMember = it->second;
++it;
LPCHARACTER pkChr;
if ((pkChr = rMember.pCharacter) && ch != pkChr)
{
DWORD x = dwArg1 + number(-500, 500);
DWORD y = dwArg2 + number(-500, 500);
pkChr->SetVictim(NULL);
pkChr->SetRotationToXY(x, y);
if (pkChr->Goto(x, y))
{
LPCHARACTER victim = pkChr->GetVictim();
sys_log(0, "%s %p RETURN victim %p", pkChr->GetName(), get_pointer(pkChr), get_pointer(victim));
pkChr->SendMovePacket(FUNC_WAIT, 0, 0, 0, 0);
}
}
}
}
break;
case PM_ATTACKED_BY: // 공격 받았음, 리더에게 도움을 요청
{
// 리더가 없을 때
LPCHARACTER pkChrVictim = ch->GetVictim();
if (!pkChrVictim)
return;
TMemberMap::iterator it = m_memberMap.begin();
while (it != m_memberMap.end())
{
TMember & rMember = it->second;
++it;
LPCHARACTER pkChr;
if ((pkChr = rMember.pCharacter) && ch != pkChr)
{
if (pkChr->CanBeginFight())
pkChr->BeginFight(pkChrVictim);
}
}
}
break;
case PM_AGGRO_INCREASE:
{
LPCHARACTER victim = CHARACTER_MANAGER::instance().Find(dwArg2);
if (!victim)
return;
TMemberMap::iterator it = m_memberMap.begin();
while (it != m_memberMap.end())
{
TMember & rMember = it->second;
++it;
LPCHARACTER pkChr;
if ((pkChr = rMember.pCharacter) && ch != pkChr)
{
pkChr->UpdateAggrPoint(victim, DAMAGE_TYPE_SPECIAL, dwArg1);
}
}
}
break;
}
}
bool CInputProcessor::Process(LPDESC lpDesc, const void * c_pvOrig, int iBytes, int & r_iBytesProceed)
{
const char * c_pData = (const char *) c_pvOrig;
BYTE bLastHeader = 0;
int iLastPacketLen = 0;
int iPacketLen;
if (!m_pPacketInfo)
{
sys_err("No packet info has been binded to");
return true;
}
for (m_iBufferLeft = iBytes; m_iBufferLeft > 0;)
{
BYTE bHeader = (BYTE) *(c_pData);
const char * c_pszName;
if (bHeader == 0) // 암호화 처리가 있으므로 0번 헤더는 스킵한다.
iPacketLen = 1;
else if (!m_pPacketInfo->Get(bHeader, &iPacketLen, &c_pszName))
{
sys_err("UNKNOWN HEADER: %d, LAST HEADER: %d(%d), REMAIN BYTES: %d, fd: %d",
bHeader, bLastHeader, iLastPacketLen, m_iBufferLeft, lpDesc->GetSocket());
//printdata((BYTE *) c_pvOrig, m_iBufferLeft);
lpDesc->SetPhase(PHASE_CLOSE);
return true;
}
if (m_iBufferLeft < iPacketLen)
return true;
if (bHeader)
{
if (test_server && bHeader != HEADER_CG_MOVE)
sys_log(0, "Packet Analyze [Header %d][bufferLeft %d] ", bHeader, m_iBufferLeft);
m_pPacketInfo->Start();
int iExtraPacketSize = Analyze(lpDesc, bHeader, c_pData);
if (iExtraPacketSize < 0)
return true;
iPacketLen += iExtraPacketSize;
lpDesc->Log("%s %d", c_pszName, iPacketLen);
m_pPacketInfo->End();
}
// TRAFFIC_PROFILER
if (g_bTrafficProfileOn)
TrafficProfiler::instance().Report(TrafficProfiler::IODIR_INPUT, bHeader, iPacketLen);
// END_OF_TRAFFIC_PROFILER
if (bHeader == HEADER_CG_PONG)
sys_log(0, "PONG! %u %u", m_pPacketInfo->IsSequence(bHeader), *(BYTE *) (c_pData + iPacketLen - sizeof(BYTE)));
if (m_pPacketInfo->IsSequence(bHeader))
{
BYTE bSeq = lpDesc->GetSequence();
BYTE bSeqReceived = *(BYTE *) (c_pData + iPacketLen - sizeof(BYTE));
if (bSeq != bSeqReceived)
{
sys_err("SEQUENCE %x mismatch 0x%x != 0x%x header %u", get_pointer(lpDesc), bSeq, bSeqReceived, bHeader);
LPCHARACTER ch = lpDesc->GetCharacter();
char buf[1024];
int offset, len;
offset = snprintf(buf, sizeof(buf), "SEQUENCE_LOG [%s]-------------\n", ch ? ch->GetName() : "UNKNOWN");
if (offset < 0 || offset >= (int) sizeof(buf))
offset = sizeof(buf) - 1;
for (size_t i = 0; i < lpDesc->m_seq_vector.size(); ++i)
{
len = snprintf(buf + offset, sizeof(buf) - offset, "\t[%03d : 0x%x]\n",
lpDesc->m_seq_vector[i].hdr,
lpDesc->m_seq_vector[i].seq);
if (len < 0 || len >= (int) sizeof(buf) - offset)
offset += (sizeof(buf) - offset) - 1;
else
offset += len;
}
snprintf(buf + offset, sizeof(buf) - offset, "\t[%03d : 0x%x]\n", bHeader, bSeq);
sys_err("%s", buf);
lpDesc->SetPhase(PHASE_CLOSE);
return true;
}
else
{
lpDesc->push_seq(bHeader, bSeq);
lpDesc->SetNextSequence();
//sys_err("SEQUENCE %x match %u next %u header %u", lpDesc, bSeq, lpDesc->GetSequence(), bHeader);
}
}
c_pData += iPacketLen;
m_iBufferLeft -= iPacketLen;
r_iBytesProceed += iPacketLen;
iLastPacketLen = iPacketLen;
bLastHeader = bHeader;
if (GetType() != lpDesc->GetInputProcessor()->GetType())
return false;
}
return true;
}
static typename result<Env,PtrActor,MemFunPtrActor>::type
eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor)
{
return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))();
}
void Table::draw_table()
{
//If drag and drag inital save not done
if(!drag_save && card_drag)
{
//Draw a proper version
draw_background();
draw_deck();
//Save it in a pixmap
back_drag->draw_drawable(get_style()->get_black_gc(),back,
0,0,0,0,-1,-1);
drag_save=true;
get_window()->draw_drawable(get_style()->get_black_gc(),back_drag,
0,0,0,0,-1,-1);
}
if(!card_drag)
{
//Draw the differents parts of the table
draw_background();
draw_deck();
//Display the entire pixmap
get_window()->draw_drawable(get_style()->get_black_gc(),back,
0,0,0,0,-1,-1);
}
//Low processor - Inspired by Belooted
else
{
int x;int y;
get_pointer(x,y);
int ax,ay,aw,ah,bw,bh,bx,by;
if(abs(x-card_dragged->drag_xb)>card_dragged->card_f->scaled->get_width() || abs(y-card_dragged->drag_yb)>card_dragged->card_f->scaled->get_height())
{
std::cout<<"X Grand"<<std::endl;
ax=card_dragged->drag_xb-card_dragged->drag_x;
ay=card_dragged->drag_yb-card_dragged->drag_y;
aw=card_dragged->card_f->scaled->get_width();
ah=card_dragged->card_f->scaled->get_height();
bx=by=bw=bh=0;
}
else
{
if(x>card_dragged->drag_xb)
{
if(y>card_dragged->drag_yb)
{
ax=card_dragged->drag_xb-card_dragged->drag_x;
ay = card_dragged->drag_yb-card_dragged->drag_y;
bx=ax;by=ay;
ah= card_dragged->card_f->scaled->get_height();
aw=x-card_dragged->drag_xb;
bh=y-card_dragged->drag_yb;
bw=card_dragged->card_f->scaled->get_width();
}
else
{
ax=card_dragged->drag_xb-card_dragged->drag_x;
ay=card_dragged->drag_yb-card_dragged->drag_y;
bx=ax;
by=y+(card_dragged->card_f->scaled->get_height()-card_dragged->drag_y);
ah= card_dragged->card_f->scaled->get_height();
aw=x-card_dragged->drag_xb;
bh=card_dragged->drag_yb-y;
bw=card_dragged->card_f->scaled->get_width();
}
}
else
{
if(y>card_dragged->drag_yb)
{
ax=card_dragged->drag_xb-card_dragged->drag_x;
ay=card_dragged->drag_yb-card_dragged->drag_y;
bx=x-card_dragged->drag_x+card_dragged->card_f->scaled->get_width();
by=ay;
ah=y-card_dragged->drag_yb;
aw=card_dragged->card_f->scaled->get_width();
bh=card_dragged->card_f->scaled->get_height();
bw=card_dragged->drag_xb-card_dragged->drag_x;
}
else
{
ax=card_dragged->drag_xb-card_dragged->drag_x;
ay=y+(card_dragged->card_f->scaled->get_height()-card_dragged->drag_y);
bx=x+(card_dragged->card_f->scaled->get_width()-card_dragged->drag_x);
by=card_dragged->drag_yb-card_dragged->drag_y;
ah=card_dragged->drag_yb-y;
aw=card_dragged->card_f->scaled->get_width();
bh=card_dragged->card_f->scaled->get_height();
bw=card_dragged->drag_xb-x;
}
}
}
//Load the saved inital table
get_window()->draw_drawable(get_style()->get_black_gc(),back_drag,
ax,ay,
ax,ay,
aw,ah);
get_window()->draw_drawable(get_style()->get_black_gc(),back_drag,
bx,by,
bx,by,
bw,bh);
card_dragged->drag_xb=x;
card_dragged->drag_yb=y;
//Draw the dragged card
get_window()->draw_pixbuf(get_style()->get_black_gc(),card_dragged->card_f->scaled,
0, 0,x-card_dragged->drag_x,y-card_dragged->drag_y,-1,-1,Gdk::RGB_DITHER_NONE, 0, 0);
}
}
void PC::AddTimer(const string & name, LPEVENT pEvent)
{
RemoveTimer(name);
m_TimerMap.insert(make_pair(name, pEvent));
sys_log(0, "QUEST add timer %p %d", get_pointer(pEvent), m_TimerMap.size());
}
T& get() { return *get_pointer(); }
const T& get() const { return *get_pointer(); }
virtual scene::IAnimatedMesh * createMesh (io::IReadFile *file)
{
video::IVideoDriver * driver = m_device->getVideoDriver();
intrusive_ptr<video::IImage> img =
intrusive_ptr<video::IImage>(driver->createImageFromFile(file), false);
if(!img)
{
return false;
}
core::dimension2d<u32> size = img->getDimension();
intrusive_ptr<scene::SMesh> mesh(new scene::SMesh, false);
intrusive_ptr<scene::IAnimatedMesh> animmesh(new scene::SAnimatedMesh(get_pointer(mesh)), false);
const u32 meshbuffer_size = driver -> getMaximalPrimitiveCount();
int rows_per_buffer = meshbuffer_size / ((size.Width-1) * 2);
int trianglecount = 2 * (size.Width-1) * (size.Height-1);
int buffercount = trianglecount/meshbuffer_size+1;
for(int i = 0; i < buffercount; i++)
{
int starty = rows_per_buffer*i;
int endy = rows_per_buffer*(i+1);
if(endy > size.Height)endy = size.Height;
// create new buffer...
scene::SMeshBuffer * buffer = new scene::SMeshBuffer;
mesh->addMeshBuffer(buffer);
buffer->drop(); // now owned by mesh
buffer->Vertices.set_used((1 + endy - starty) * size.Width);
int idx = 0;
for(int y = starty; y < endy; y++)
{
for(int x = 0; x < size.Width; x++)
{
// center the model around -0.5 -> 0.5 on every axis
float pz = get_height(get_pointer(img), x, y);
float px = float(x)/(size.Width-1);
float py = float(y)/(size.Height-1);
video::S3DVertex& v = buffer->Vertices[idx++];
v.Pos.set(-0.5+px, -0.5+py, -0.5+pz);
v.Normal.set(0,0,1);
if(x < size.Width-1)
v.Normal.X -= size.Width/(get_height(get_pointer(img), x+1, y)-get_height(get_pointer(img), x, y));
if(x > 0)
v.Normal.X += size.Width/(get_height(get_pointer(img), x-1, y)-get_height(get_pointer(img), x, y));
if(y < size.Height-1)
v.Normal.Y -= size.Height/(get_height(get_pointer(img), x, y+1)-get_height(get_pointer(img), x, y));
if(y > 0)
v.Normal.Y += size.Height/(get_height(get_pointer(img), x, y-1)-get_height(get_pointer(img), x, y));
v.Normal.normalize();
v.Color.set(255,255,255,255);
v.TCoords.set(px, py);
}
}
idx = 0;
buffer->Indices.set_used(6 * (size.Width-1) * (endy-starty));
for(int y = starty; y < endy; y++)
{
for(int x = 0; x < size.Width-1; x++)
{
int n = (y-starty) * size.Width + x;
buffer->Indices[idx++] = n;
buffer->Indices[idx++] = n + size.Height + 1;
buffer->Indices[idx++] = n + size.Height;
buffer->Indices[idx++] = n + size.Height + 1;
buffer->Indices[idx++] = n;
buffer->Indices[idx++] = n + 1;
}
}
buffer -> recalculateBoundingBox();
}
// make animmesh outlive this scope
animmesh->grab();
return get_pointer(animmesh);
}
wrap_base const* get_back_reference_aux2(T const& x, mpl::true_)
{
return get_back_reference_aux1(get_pointer(x));
}
void OXMLi_ListenerState_Table::startElement (OXMLi_StartElementRequest * rqst)
{
if (nameMatches(rqst->pName, NS_W_KEY, "tbl"))
{
OXML_Element_Table* pTable = new OXML_Element_Table("");
m_tableStack.push(pTable);
OXML_SharedElement table(pTable);
rqst->stck->push(table);
rqst->handled = true;
pTable->setCurrentRowNumber(-1);
pTable->setCurrentColNumber(-1);
}
else if(nameMatches(rqst->pName, NS_W_KEY, "tr"))
{
if(m_tableStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Table* table = m_tableStack.top();
OXML_Element_Row* pRow = new OXML_Element_Row("", table);
m_rowStack.push(pRow);
OXML_SharedElement row(pRow);
rqst->stck->push(row);
rqst->handled = true;
table->incrementCurrentRowNumber();
table->setCurrentColNumber(0);
pRow->setRowNumber(table->getCurrentRowNumber());
}
else if(nameMatches(rqst->pName, NS_W_KEY, "tc"))
{
if(m_tableStack.empty() || m_rowStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Table* table = m_tableStack.top();
OXML_Element_Row* row = m_rowStack.top();
OXML_Element_Cell* pCell = new OXML_Element_Cell("", table, row,
table->getCurrentColNumber(), table->getCurrentColNumber()+1, //left right
table->getCurrentRowNumber(), table->getCurrentRowNumber()+1); //top,bottom
m_cellStack.push(pCell);
OXML_SharedElement cell(pCell);
rqst->stck->push(cell);
rqst->handled = true;
table->incrementCurrentColNumber();
}
else if(nameMatches(rqst->pName, NS_W_KEY, "gridSpan"))
{
if(m_tableStack.empty() || m_cellStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Table* table = m_tableStack.top();
const gchar* val = attrMatches(NS_W_KEY, "val", rqst->ppAtts);
if(val)
{
int span = atoi(val);
int left = table->getCurrentColNumber()-1;
int right = left + span;
//change current cell's right index
OXML_Element_Cell* cell = m_cellStack.top();
cell->setRight(right);
//update column index of current table
table->setCurrentColNumber(right);
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "vMerge"))
{
if(m_cellStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Cell* cell = m_cellStack.top();
cell->setVerticalMergeStart(false); //default to continue if the attribute is missing
const gchar* val = attrMatches(NS_W_KEY, "val", rqst->ppAtts);
if(val && !strcmp(val, "restart"))
{
cell->setVerticalMergeStart(true);
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "hMerge"))
{
if(m_cellStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Cell* cell = m_cellStack.top();
cell->setHorizontalMergeStart(false); //default to continue if the attribute is missing
const gchar* val = attrMatches(NS_W_KEY, "val", rqst->ppAtts);
if(val && !strcmp(val, "restart"))
{
cell->setHorizontalMergeStart(true);
}
rqst->handled = true;
}
//Table Properties
else if(nameMatches(rqst->pName, NS_W_KEY, "gridCol") &&
contextMatches(rqst->context->back(), NS_W_KEY, "tblGrid"))
{
if(m_tableStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Table* table = m_tableStack.top();
const gchar* w = attrMatches(NS_W_KEY, "w", rqst->ppAtts);
if(w)
{
//append this width to table-column-props property
const gchar* tableColumnProps = NULL;
UT_Error ret = table->getProperty("table-column-props", tableColumnProps);
if((ret != UT_OK) || !tableColumnProps)
tableColumnProps = "";
std::string cols(tableColumnProps);
cols += _TwipsToPoints(w);
cols += "pt/";
ret = table->setProperty("table-column-props", cols);
if(ret != UT_OK)
{
UT_DEBUGMSG(("FRT:OpenXML importer can't set table-column-props:%s\n", cols.c_str()));
}
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "trHeight") &&
contextMatches(rqst->context->back(), NS_W_KEY, "trPr"))
{
if(m_tableStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Table* table = m_tableStack.top();
const gchar* val = attrMatches(NS_W_KEY, "val", rqst->ppAtts);
if(val)
{
const gchar* tableRowHeights = NULL;
UT_Error ret = table->getProperty("table-row-heights", tableRowHeights);
if((ret != UT_OK) || !tableRowHeights)
tableRowHeights = "";
std::string rowHeights(tableRowHeights);
rowHeights += _TwipsToPoints(val);
rowHeights += "pt/";
ret = table->setProperty("table-row-heights", rowHeights);
if(ret != UT_OK)
{
UT_DEBUGMSG(("FRT:OpenXML importer can't set table-row-heights:%s\n", rowHeights.c_str()));
}
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "left") ||
nameMatches(rqst->pName, NS_W_KEY, "right") ||
nameMatches(rqst->pName, NS_W_KEY, "top") ||
nameMatches(rqst->pName, NS_W_KEY, "bottom"))
{
rqst->handled = true;
const gchar* color = attrMatches(NS_W_KEY, "color", rqst->ppAtts);
const gchar* sz = attrMatches(NS_W_KEY, "sz", rqst->ppAtts);
const gchar* val = attrMatches(NS_W_KEY, "val", rqst->ppAtts);
UT_Error ret = UT_OK;
std::string borderName(rqst->pName);
borderName = borderName.substr(strlen(NS_W_KEY)+1);
if(!borderName.compare("bottom"))
borderName = "bot";
std::string borderStyle = borderName + "-style";
std::string borderColor = borderName + "-color";
std::string borderThickness = borderName + "-thickness";
OXML_Element* element = NULL;
if(rqst->context->empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
if(contextMatches(rqst->context->back(), NS_W_KEY, "tcBorders"))
element = m_cellStack.empty() ? NULL : m_cellStack.top();
else if(contextMatches(rqst->context->back(), NS_W_KEY, "tblBorders"))
element = m_tableStack.empty() ? NULL : m_tableStack.top();
if(!element)
{
rqst->handled = false;
rqst->valid = false;
return;
}
if(color && strcmp(color, "auto"))
{
ret = element->setProperty(borderColor, color);
if(ret != UT_OK)
{
UT_DEBUGMSG(("FRT:OpenXML importer can't set %s:%s\n", borderColor.c_str(), color));
}
}
if(sz)
{
std::string szVal(_EighthPointsToPoints(sz));
szVal += "pt";
ret = element->setProperty(borderThickness, szVal);
if(ret != UT_OK)
{
UT_DEBUGMSG(("FRT:OpenXML importer can't set %s:%s\n", borderThickness.c_str(), color));
}
}
std::string styleValue = "1"; //single line border by default
if(val)
{
if(!strcmp(val, "dashed"))
styleValue = "0";
}
ret = element->setProperty(borderStyle, styleValue);
if(ret != UT_OK)
{
UT_DEBUGMSG(("FRT:OpenXML importer can't set %s:0\n", borderStyle.c_str()));
}
}
else if(nameMatches(rqst->pName, NS_W_KEY, "shd"))
{
const gchar* fill = attrMatches(NS_W_KEY, "fill", rqst->ppAtts);
UT_Error ret = UT_OK;
OXML_Element* element = NULL;
if(rqst->context->empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
if(contextMatches(rqst->context->back(), NS_W_KEY, "tcPr"))
element = m_cellStack.empty() ? NULL : m_cellStack.top();
else if(contextMatches(rqst->context->back(), NS_W_KEY, "tblPr"))
element = m_tableStack.empty() ? NULL : m_tableStack.top();
if(!element)
{
rqst->handled = false;
rqst->valid = false;
return;
}
if(fill && strcmp(fill, "auto"))
{
ret = element->setProperty("background-color", fill);
if(ret != UT_OK)
{
UT_DEBUGMSG(("FRT:OpenXML importer can't set background-color:%s\n", fill));
}
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "tblStyle"))
{
if(m_tableStack.empty())
{
rqst->handled = false;
rqst->valid = false;
return;
}
OXML_Element_Table* table = m_tableStack.top();
const gchar* val = attrMatches(NS_W_KEY, "val", rqst->ppAtts);
if(val && table)
{
std::string styleName(val);
OXML_Document* doc = OXML_Document::getInstance();
if(doc)
table->applyStyle(doc->getStyleById(styleName));
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "tblPr"))
{
if(m_tableStack.empty())
{
//we must be in tblStyle in styles, so let's push the table instance to m_tableStack
OXML_Element_Table* tbl = static_cast<OXML_Element_Table*>(get_pointer(rqst->stck->top()));
m_tableStack.push(tbl);
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "trPr"))
{
if(m_rowStack.empty())
{
//we must be in styles, so let's push the row instance to m_rowStack
OXML_Element_Row* row = static_cast<OXML_Element_Row*>(get_pointer(rqst->stck->top()));
m_rowStack.push(row);
}
rqst->handled = true;
}
else if(nameMatches(rqst->pName, NS_W_KEY, "tcPr"))
{
if(m_cellStack.empty())
{
//we must be in styles, so let's push the cell instance to m_cellStack
OXML_Element_Cell* cell = static_cast<OXML_Element_Cell*>(get_pointer(rqst->stck->top()));
m_cellStack.push(cell);
}
rqst->handled = true;
}
//TODO: more coming here
}
static int init_geom(client_t *c, strut_t *s)
{
Atom win_type, state;
int screen_x = DisplayWidth(dpy, screen);
int screen_y = DisplayHeight(dpy, screen);
int wmax = screen_x - s->left - s->right;
int hmax = screen_y - s->top - s->bottom;
int mouse_x, mouse_y;
/* We decide the geometry for these types of windows, so we can just
* ignore everything and return right away. If c->zoomed is set, that
* means we've already set things up, but otherwise, we do it here. */
if (c->zoomed)
return 1;
if (get_atoms(c->win, net_wm_state, XA_ATOM, 0, &state, 1, NULL) &&
state == net_wm_state_fs) {
c->geom.x = 0;
c->geom.y = 0;
c->geom.w = screen_x;
c->geom.h = screen_y;
return 1;
}
/* Here, we merely set the values; they're in the same place regardless
* of whether the user or the program specified them. We'll distinguish
* between the two cases later, if we need to. */
if (c->size.flags & (USSize|PSize)) {
if (c->size.width > 0) c->geom.w = c->size.width;
if (c->size.height > 0) c->geom.h = c->size.height;
}
if (c->size.flags & (USPosition|PPosition)) {
if (c->size.x > 0) c->geom.x = c->size.x;
if (c->size.y > 0) c->geom.y = c->size.y;
}
/* Several types of windows can put themselves wherever they want, but we
* need to read the size hints to get that position before returning. */
if (get_atoms(c->win, net_wm_wintype, XA_ATOM, 0, &win_type, 1, NULL) &&
CAN_PLACE_SELF(win_type))
return 1;
/* At this point, maybe nothing was set, or something went horribly wrong
* and the values are garbage. So, make a guess, based on the pointer. */
if (c->geom.x <= 0 && c->geom.y <= 0) {
get_pointer(&mouse_x, &mouse_y);
recalc_map(c, c->geom, mouse_x, mouse_y, mouse_x, mouse_y, s);
}
/* In any case, if we got this far, we need to do a further sanity check
* and make sure that the window isn't overlapping any struts -- except
* for transients, because they might be a panel-type client popping up a
* notification window over themselves. */
if (!c->trans) {
if (c->geom.x + c->geom.w > screen_x - s->right)
c->geom.x = screen_x - s->right - c->geom.w;
if (c->geom.y + c->geom.h > screen_y - s->bottom)
c->geom.y = screen_y - s->bottom - c->geom.h;
if (c->geom.x < s->left || c->geom.w > wmax)
c->geom.x = s->left;
if (c->geom.y < s->top || c->geom.h > hmax)
c->geom.y = s->top;
}
/* Finally, we decide if we were ultimately satisfied with the position
* given, or if we had to make something up, so that the caller can
* consider using some other method. */
return c->trans || c->size.flags & USPosition;
}
bool
perfroll::on_key_press_event(GdkEventKey* a_p0)
{
if (a_p0->keyval == m_mainperf->m_key_pointer) /* Move to mouse position */
{
int x = 0;
int y = 0;
long a_tick = 0;
get_pointer(x, y);
if(x < 0)
x = 0;
snap_x(&x);
convert_x(x, &a_tick);
if(m_mainperf->is_jack_running())
{
m_mainperf->set_reposition();
m_mainperf->set_starting_tick(a_tick);
m_mainperf->position_jack(true, a_tick);
}
else
{
m_mainperf->set_reposition();
m_mainperf->set_starting_tick(a_tick);
}
return true;
}
bool ret = false;
if ( m_mainperf->is_active( m_drop_sequence))
{
if ( a_p0->type == GDK_KEY_PRESS )
{
if ( a_p0->keyval == GDK_Delete || a_p0->keyval == GDK_BackSpace )
{
m_mainperf->push_trigger_undo(m_drop_sequence);
m_mainperf->get_sequence( m_drop_sequence )->del_selected_trigger();
ret = true;
}
if ( a_p0->state & GDK_CONTROL_MASK )
{
/* cut */
if ( a_p0->keyval == GDK_x || a_p0->keyval == GDK_X )
{
m_mainperf->push_trigger_undo(m_drop_sequence);
m_mainperf->get_sequence( m_drop_sequence )->cut_selected_trigger();
ret = true;
}
/* copy */
if ( a_p0->keyval == GDK_c || a_p0->keyval == GDK_C )
{
m_mainperf->get_sequence( m_drop_sequence )->copy_selected_trigger();
ret = true;
}
/* paste */
if ( a_p0->keyval == GDK_v || a_p0->keyval == GDK_V )
{
m_mainperf->push_trigger_undo(m_drop_sequence);
m_mainperf->get_sequence( m_drop_sequence )->paste_trigger();
ret = true;
}
}
}
}
if ( ret == true )
{
fill_background_pixmap();
queue_draw();
return true;
}
else
return false;
}
static void get_drive(Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp)
{
get_pointer(obj, v, opaque, print_drive, name, errp);
}
void OXML_Element_Table::applyStyle(OXML_SharedStyle style)
{
inheritProperties(get_pointer(style));
}
