~ubuntu-branches/debian/jessie/python-uniconvertor/jessie : revision 3

44

45

from app import Rect, Point, UnionRects, InfinityRect, Trafo, Rotation, Translation, Scale

46

from app import UndoRedo, Undo, CreateListUndo, NullUndo, UndoAfter

47

import app

48

import color, selinfo, pagelayout

49

50

from base import Protocols

56

import guide

57

from selection import SizeSelection, EditSelection, TrafoSelection, TrafoRectangle

58

from math import *

59

from app.conf.const import STYLE, SELECTION, EDITED, MODE, UNDO, REDRAW, LAYOUT

59

from app.conf.const import STYLE, SELECTION, EDITED, MODE, UNDO, REDRAW, LAYOUT, PAGE

60

from app.conf.const import LAYER, LAYER_ORDER, LAYER_ACTIVE, GUIDE_LINES, GRID

61

from app.conf.const import SelectSet, SelectAdd,SelectSubtract,SelectSubobjects,\

62

SelectDrag, SelectGuide, Button1Mask

76

script_access = {}

77

78

def __init__(self, create_layer = 0):

79

self.pages = []

80

self.active_page=0

79

81

self.snap_grid = GridLayer()

80

82

self.snap_grid.SetDocument(self)

81

83

self.guide_layer = GuideLayer(_("Guide Lines"))

82

84

self.guide_layer.SetDocument(self)

85

layer=Layer(_("MasterLayer 1"))

86

layer.SetDocument(self)

87

layer.is_MasterLayer=1

88

self.master_layers=[layer]

83

89

if create_layer:

84

90

# a new empty document

85

91

self.active_layer = Layer(_("Layer 1"))

86

92

self.active_layer.SetDocument(self)

87

self.layers = [self.active_layer, self.guide_layer,

88

self.snap_grid]

93

self.layers = [self.snap_grid]+[self.active_layer] + self.master_layers + [self.guide_layer]

94

self.pages.append([self.active_layer])

89

95

else:

90

96

# we're being created by the load module

91

97

self.active_layer = None

92

98

self.layers = []

99

self.pages.append(self.layers)

93

100

94

101

def __del__(self):

95

102

if __debug__:

105

112

return self.layers[idx[0]]

106

113

raise ValueError, 'invalid index %s' % `idx`

107

114

108

def AppendLayer(self, layer_name = None, *args, **kw_args):

115

def AppendLayer(self, layer_name = None, master=0, *args, **kw_args):

109

116

try:

110

117

old_layers = self.layers[:]

111

118

if layer_name is None:

114

121

layer_name = str(layer_name)

115

122

layer = apply(Layer, (layer_name,) + args, kw_args)

116

123

layer.SetDocument(self)

117

self.layers.append(layer)

124

if master:

125

layer.is_MasterLayer=1

126

mlayers=self.getMasterLayers()

127

mlayers.append(layer)

128

self.layers = [self.snap_grid] + self.getRegularLayers() + mlayers + [self.guide_layer]

129

else:

130

rlayers=self.getRegularLayers()

131

rlayers.append(layer)

132

self.layers = [self.snap_grid] + rlayers + self.getMasterLayers() + [self.guide_layer]

118

133

if not self.active_layer:

119

self.active_layer = layer

134

self.active_layer = layer

120

135

return layer

121

136

except:

122

137

self.layers[:] = old_layers

123

138

raise

124

139

script_access['AppendLayer'] = SCRIPT_OBJECT

140

141

def RearrangeLayers(self):

142

if not len(self.getMasterLayers()):

143

layer=Layer(_("MasterLayer 1"))

144

layer.SetDocument(self)

145

layer.is_MasterLayer=1

146

self.layers.append(layer)

147

self.layers = [self.snap_grid] + self.getRegularLayers() + self.getMasterLayers() + [self.guide_layer]

148

149

def getRegularLayers(self):

150

result=[]

151

for layer in self.layers:

152

if not layer.is_SpecialLayer and not layer.is_MasterLayer:

153

result.append(layer)

154

return result

155

156

def getMasterLayers(self):

157

result=[]

158

for layer in self.layers:

159

if layer.is_MasterLayer:

160

result.append(layer)

161

return result

162

163

def insert_pages(self, number=1, index=0, is_before=0):

164

for item in range(number):

165

if is_before:

166

self.pages.insert(index, self.NewPage())

167

self.active_page+=1

168

self.setActivePage(index)

169

else:

170

self.pages.insert(index+item+1, self.NewPage())

171

self.setActivePage(index+1)

172

173

def setActivePage(self, index):

174

self.pages[self.active_page]=self.getRegularLayers()

175

self.layers=[self.snap_grid] + self.pages[index] + self.getMasterLayers() + [self.guide_layer]

176

self.active_page=index

177

self.active_layer=(self.pages[index])[0]

178

179

def updateActivePage(self):

180

self.pages[self.active_page]=self.getRegularLayers()

181

182

def NewPage(self):

183

page=[]

184

new_layer=Layer(_("Layer 1"))

185

new_layer.SetDocument(self)

186

page.append(new_layer)

187

return page

188

189

def delete_page(self, index=0):

190

if len(self.pages)==1:

191

return

192

if self.active_page and index == self.active_page:

193

self.setActivePage(index-1)

194

if not self.active_page and index == self.active_page:

195

self.setActivePage(1)

196

self.active_page=0

197

if self.active_page and self.active_page>index:

198

self.active_page-=1

199

self.pages.remove(self.pages[index])

200

201

def delete_pages(self, number=1, index=0,is_before=0):

202

for item in range(number):

203

self.delete_page(index+is_before)

204

205

def move_page(self, index=0, backward=0):

206

if index==0 or index==len(self.pages)-1:

207

return

208

else:

209

page=self.pages[index]

210

self.pages.remove(page)

211

self.pages.insert(index+1-2*backward, page)

212

if index==self.active_page:

213

self.active_page=self.active_page+1-2*backward

214

125

215

126

216

def BoundingRect(self, visible = 1, printable = 0):

127

217

rects = []

209

299

return join(info, '\n')

210

300

211

301

def SaveToFile(self, file):

302

self.updateActivePage()

212

303

file.BeginDocument()

213

304

self.page_layout.SaveToFile(file)

214

305

self.write_styles(file)

215

for layer in self.layers:

216

layer.SaveToFile(file)

306

self.snap_grid.SaveToFile(file)

307

308

pagesnum=len(self.pages)

309

pagecount=0

310

interval=100/pagesnum

311

for page in self.pages:

312

file.Page()

313

pagecount+=1

314

app.updateInfo(inf2=_('Saving page %u of %u')%(pagecount,pagesnum),

315

inf3=interval*pagecount)

316

layercount=0

317

layersnum=len(page)

318

l_interval=interval/layersnum

319

for layer in page:

320

layercount+=1

321

app.updateInfo(inf2=_('Saving page %u of %u, layer %u of %u')%

322

(pagecount,pagesnum,layercount,layersnum),

323

inf3=interval*pagecount)

324

layer.SaveToFile(file)

325

326

for layer in self.getMasterLayers():

327

layer.SaveToFile(file)

328

self.guide_layer.SaveToFile(file)

217

329

file.EndDocument()

218

330

219

331

def load_AppendObject(self, layer):

243

355

self.layers.append(self.guide_layer)

244

356

if add_grid_layer:

245

357

self.layers.append(self.snap_grid)

246

358

self.extract_pages()

359

self.RearrangeLayers()

360

361

def extract_pages(self):

362

layers=self.getRegularLayers()

363

if layers[0].is_Page:

364

self.pages=[]

365

for layer in layers:

366

if layer.is_Page:

367

page=[]

368

self.pages.append(page)

369

else:

370

page.append(layer)

371

pages=[]+self.pages

372

for page in pages:

373

if not len(page):

374

self.pages.remove(page)

375

else:

376

self.pages=[]

377

self.pages.append(layers)

378

self.active_page=0

379

self.layers=[self.snap_grid] + self.pages[0] + self.getMasterLayers() + [self.guide_layer]

380

self.active_layer=(self.pages[0])[0]

247

381

248

382

#

249

383

# Class MetaInfo

506

640

self.end_transaction(queue_edited = 1)

507

641

508

642

def Insert(self, object, undo_text = _("Create Object")):

643

group_flag = 0

509

644

if isinstance(object, guide.GuideLine):

510

645

self.add_guide_line(object)

511

646

else:

512

647

self.begin_transaction(undo_text, clear_selection_rect = 0)

513

648

try:

514

649

try:

515

object.SetDocument(self)

650

if type(object) == ListType:

651

gobject = Group(object)

652

else:

653

gobject = object

516

654

selected, undo = self.insert(object)

517

655

self.add_undo(undo)

518

self.add_undo(self.AddClearRect(object.bounding_rect))

656

self.add_undo(self.AddClearRect(gobject.bounding_rect))

519

657

self.__set_selection(selected, SelectSet)

658

self.add_undo(self.remove_selected())

659

660

extracted_select=[]

661

for info, object in self.selection.GetInfo():

662

objects=[]

663

if type(object) == ListType:

664

objects = object

665

else:

666

objects.append(object)

667

select, undo_insert = self.insert(objects, at = info[1:], layer = info[0])

668

extracted_select+=select

669

self.add_undo(undo_insert)

670

self.__set_selection(extracted_select, SelectSet)

520

671

except:

521

672

self.abort_transaction()

522

673

finally:

553

704

# guide lines cannot be selected in the

554

705

# ordinary way, but other objects on the

555

706

# guide layer can.

707

# pass

708

########################################################################

709

########################################################################

556

710

selected = None

557

711

self.__set_selection(selected, type)

558

712

1241

1395

1242

1396

def WasEdited(self):

1243

1397

# return true if document has changed since last save

1244

return self.undo.UndoCount()

1398

if self.undo.UndoCount():

1399

return 1

1400

return 0

1245

1401

script_access['WasEdited'] = SCRIPT_GET

1246

1402

1247

1403

def ClearEdited(self):

1274

1430

# XXX this method should be removed in favour of the more

1275

1431

# generic SetProperties.

1276

1432

self.SetProperties(line_pattern = SolidPattern(color),

1277

if_type_present = 1)

1433

if_type_present = 0)

1278

1434

1279

1435

def SetProperties(self, **kw):

1280

1436

self.apply_to_selected(_("Set Properties"),

1384

1540

copies.append(obj.Duplicate())

1385

1541

1386

1542

if len(copies) > 1:

1387

copies = Group(copies)

1543

for copy in copies:

1544

copy.UntieFromDocument()

1545

copy.SetDocument(None)

1388

1546

else:

1389

copies = copies[0]

1547

copy = copies[0]

1390

1548

# This is ugly: Special case for internal path text objects.

1391

1549

# If the internal path text object is the only selected

1392

1550

# object, turn the copy into a normal simple text object.

1393

1551

# Thsi avoids some of the problems when you "Copy" an

1394

1552

# internal path text.

1395

1553

import text

1396

if copies.is_PathTextText:

1397

properties = copies.Properties().Duplicate()

1398

copies = text.SimpleText(text = copies.Text(),

1554

if copy.is_PathTextText:

1555

properties = copy.Properties().Duplicate()

1556

copy = text.SimpleText(text = copy.Text(),

1399

1557

properties = properties)

1400

1558

1401

copies.UntieFromDocument()

1402

copies.SetDocument(None)

1559

copy.UntieFromDocument()

1560

copy.SetDocument(None)

1561

copies[0]=copy

1562

1403

1563

return copies

1404

1564

1405

1565

def CopyForClipboard(self):

1475

1635

1476

1636

def CanUngroupAll(self):

1477

1637

infos = self.selection.GetInfo()

1638

isGroup=0

1478

1639

if len(infos) > 0:

1479

isGroup=infos[0][-1].is_Group

1480

for i in range(len(infos)):

1481

if infos[i][-1].is_Group:

1482

isGroup=infos[i][-1].is_Group

1640

for i in range(len(infos)):

1641

isGroup+=infos[i][-1].is_Group

1642

#if len(infos) > 0:

1643

#isGroup=infos[0][-1].is_Group

1644

#for i in range(len(infos)):

1645

#if infos[i][-1].is_Group:

1646

#isGroup=infos[i][-1].is_Group

1483

1647

return len(infos) > 0 and isGroup

1484

1648

1485

1649

def UngroupSelected(self):

1498

1662

self.abort_transaction()

1499

1663

finally:

1500

1664

self.end_transaction()

1665

1666

def ExtractNonGroup(self, object):

1667

objects=[]

1668

if object.is_Group:

1669

for item in object.objects:

1670

objects+=self.ExtractNonGroup(item)

1671

else:

1672

objects.append(object)

1673

return objects

1501

1674

1502

1675

def UngroupAllSelected(self):

1503

1676

if self.CanUngroupAll():

1504

1677

self.begin_transaction(_("Ungroup All"))

1505

1678

try:

1506

1679

try:

1507

while self.CanUngroupAll():

1508

selection = []

1509

undo_g=[]

1510

infos = self.selection.GetInfo()

1511

self.add_undo(self.remove_selected())

1512

for i in range(len(infos)):

1513

info, group = self.selection.GetInfo()[i]

1514

if group.is_Group:

1515

objects = group.Ungroup()

1516

select, undo_insert = self.insert(objects, at = info[1:], layer = info[0])

1517

selection=selection+select

1518

else:

1519

objects = group

1520

select, undo_insert = self.insert(objects, at = info[1:], layer = info[0])

1521

selection.append((info, group))

1522

self.add_undo(undo_insert)

1523

self.SelectNone()

1524

self.__set_selection(selection, SelectSet)

1525

#self.SelectObject(selection, SelectSet)

1680

self.add_undo(self.remove_selected())

1681

extracted_select=[]

1682

for info, object in self.selection.GetInfo():

1683

objects = self.ExtractNonGroup(object)

1684

select, undo_insert = self.insert(objects, at = info[1:], layer = info[0])

1685

extracted_select+=select

1686

self.add_undo(undo_insert)

1687

self.__set_selection(extracted_select, SelectSet)

1526

1688

except:

1527

1689

self.abort_transaction()

1528

1690

finally:

1529

1691

self.end_transaction()

1692

1693

def ModifyAndCopy(self):

1694

if self.selection:

1695

copies=self.copy_objects(self.selection.GetObjects())

1696

self.Undo()

1697

self.Insert(copies, undo_text=_("Modify&Copy"))

1530

1698

1531

1699

def CanCreateMaskGroup(self):

1532

1700

infos = self.selection.GetInfo()

1715

1883

self.abort_transaction()

1716

1884

finally:

1717

1885

self.end_transaction()

1886

1887

def HandleMoveSelected(self, h, v):

1888

val=config.preferences.handle_jump

1889

self.MoveSelected(h*val, v*val)

1718

1890

1719

1891

def MoveSelected(self, h, v):

1720

1892

if self.selection:

1724

1896

#cnt = self.selection.coord_rect.center()

1725

1897

text = _("Move")

1726

1898

#angle=angle*pi/180

1727

trafo = Translation(h*2.83465, v*2.83465)

1899

trafo = Translation(h, v)

1728

1900

self.TransformSelected(trafo, text)

1729

1901

except:

1730

1902

self.abort_transaction()

2039

2211

finally:

2040

2212

self.end_transaction()

2041

2213

2042

#

2043

#

2214

2215

#

2216

# PAGES MANAGMENT

2217

#

2218

2219

############

2220

def CanGoToPage(self):

2221

return len(self.pages)>1

2222

2223

def GoToPage(self, index=0):

2224

self.begin_transaction(_("Go to page"),clear_selection_rect = 0)

2225

try:

2226

try:

2227

current_page=self.active_page

2228

if self.CanUndo():

2229

self.add_undo((self._return_to_page, current_page))

2230

self.setActivePage(index)

2231

except:

2232

self.abort_transaction()

2233

finally:

2234

self.end_transaction()

2235

self.issue(PAGE)

2236

2237

def _return_to_page(self, index):

2238

current_page=self.active_page

2239

self.setActivePage(index)

2240

self.issue(PAGE)

2241

return (self._return_to_page, current_page)

2242

2243

############

2244

def InsertPages(self, number=1, index=0, is_before=0):

2245

if number>1:

2246

self.begin_transaction(_("Insert Pages"), clear_selection_rect = 0)

2247

else:

2248

self.begin_transaction(_("Insert Page"), clear_selection_rect = 0)

2249

try:

2250

try:

2251

for_del=abs(is_before-1)

2252

self.add_undo((self._delete_pages,number,index,for_del))

2253

self.insert_pages(number,index,is_before)

2254

except:

2255

self.abort_transaction()

2256

finally:

2257

self.end_transaction()

2258

self.issue(PAGE)

2259

2260

def _insert_pages(self,number,index,is_before):

2261

self.insert_pages(number,index,is_before)

2262

self.issue(PAGE)

2263

return (self._delete_pages,number,index,is_before)

2264

2265

def _delete_pages(self, number=1, index=0,is_before=0):

2266

self.delete_pages(number,index,is_before)

2267

self.issue(PAGE)

2268

return (self._insert_pages,number,index,is_before)

2269

2270

############

2271

def CanDeletePage(self,index):

2272

return 0 <= index < len(self.pages) and len(self.pages) > 1

2273

2274

def CanBePageDeleting(self):

2275

return len(self.pages) > 1

2276

2277

def DeletePage(self, index=0):

2278

if self.CanDeletePage(index):

2279

self.begin_transaction(_("Delete Page"), clear_selection_rect = 0)

2280

try:

2281

try:

2282

self.add_undo((self._insert_page,index,self.pages[index]))

2283

self.delete_page(index)

2284

except:

2285

self.abort_transaction()

2286

finally:

2287

self.end_transaction()

2288

self.issue(PAGE)

2289

2290

def _insert_page(self,index,page):

2291

current_page = self.pages[self.active_page]

2292

self.pages.insert(index,page)

2293

self.active_page = self.pages.index(current_page)

2294

self.SelectNone()

2295

self.issue(PAGE)

2296

return (self._delete_page,index,page)

2297

2298

def _delete_page(self,index,page):

2299

current_page = self.pages[self.active_page]

2300

self.pages.remove(page)

2301

self.active_page = self.pages.index(current_page)

2302

self.SelectNone()

2303

self.issue(PAGE)

2304

return (self._insert_page,index,page)

2305

2306

2307

#

2308

# LAYERS METHODS

2044

2309

#

2045

2310

2046

2311

def Layers(self):

2555

2820

return Group(groups)

2556

2821

else:

2557

2822

return None

2558

2823